From 9cf3fa696242f79ed656b8f8759c2b3c9e5359b9 Mon Sep 17 00:00:00 2001 From: Dmitry Prudnikov Date: Sat, 31 Oct 2026 22:16:59 +0200 Subject: [PATCH 1/4] feat(xades): validate B-T, B-LT and B-LTA - Add `validate` over the document's own timestamps, validation material and archives, through structured-xades and structured-ltv. - Add caller inputs: anchors, TSA policy accuracy, OCSP responders, CRLs, OCSP responses and an explicit timestamp token profile. - Report a RenewedDigestsV2 property that does not confirm its object. - Let a CRL or delta entry win over a good OCSP answer. - Build the adapter without std and execute B-LTA in WebAssembly. - Compare level fixtures with EU DSS and gate on signatures DSS made. - Update the structured primitives to 0.20 and drop the aws-lc pins. Closes #282 --- .github/workflows/ci.yml | 4 + Cargo.toml | 14 +- README.md | 37 +- benchmarks/competitors/Cargo.lock | 12 +- crates/xml-sec-xades/Cargo.toml | 28 +- crates/xml-sec-xades/examples/level_probe.rs | 199 +++ crates/xml-sec-xades/src/accuracy.rs | 87 ++ crates/xml-sec-xades/src/basic.rs | 256 +++- crates/xml-sec-xades/src/binary.rs | 38 +- crates/xml-sec-xades/src/level.rs | 1078 +++++++++++++++++ crates/xml-sec-xades/src/lib.rs | 36 +- crates/xml-sec-xades/src/path.rs | 141 ++- crates/xml-sec-xades/src/signature.rs | 20 + crates/xml-sec-xades/src/status.rs | 963 +++++++++++++++ crates/xml-sec-xades/tests/element.rs | 172 +++ .../levels/b-lt-configured-responder.xml | 90 ++ .../levels/b-lt-conflicting-delta.xml | 90 ++ .../levels/b-lt-conflicting-status.xml | 90 ++ .../fixtures/levels/b-lt-countersigned.xml | 150 +++ .../tests/fixtures/levels/b-lt-detached.xml | 86 ++ .../fixtures/levels/b-lt-responder-by-key.xml | 90 ++ .../tests/fixtures/levels/b-lt-tsa-delta.xml | 90 ++ .../levels/b-lt-tsa-material-misplaced.xml | 90 ++ .../fixtures/levels/b-lt-tsa-revoked.xml | 90 ++ .../tests/fixtures/levels/b-lt.xml | 90 ++ .../fixtures/levels/b-lta-renewed-digests.xml | 87 ++ .../tests/fixtures/levels/b-lta-renewed.xml | 90 ++ .../tests/fixtures/levels/b-lta.xml | 90 ++ .../tests/fixtures/levels/b-t-no-accuracy.xml | 90 ++ .../tests/fixtures/levels/b-t-parallel.xml | 171 +++ .../tests/fixtures/levels/b-t.xml | 90 ++ .../tests/fixtures/levels/detached.txt | 1 + .../tests/fixtures/levels/issuer.der | Bin 0 -> 834 bytes .../tests/fixtures/levels/outsider.der | Bin 0 -> 861 bytes .../tests/fixtures/levels/root.der | Bin 0 -> 796 bytes crates/xml-sec-xades/tests/levels.rs | 865 +++++++++++++ docs/features.md | 6 - interop/xades/README.md | 21 +- interop/xades/SHA256SUMS | 5 +- interop/xades/dss/pom.xml | 1 + .../xades/dss/src/main/java/LevelProbe.java | 52 + src/xmldsig/extension/tree.rs | 26 +- src/xmldsig/pkix.rs | 2 +- src/xmldsig/verify/session.rs | 34 +- src/xmldsig/verify/session/element.rs | 95 ++ src/xmldsig/verify/session/lookup.rs | 15 + tests/cms_timestamp.rs | 1 + tests/wasm-smoke/Cargo.toml | 7 +- tests/wasm-smoke/src/lib.rs | 75 +- tools/xml-sec-tools/src/wasm_smoke.rs | 7 +- tools/xml-sec-tools/src/wasm_smoke/tests.rs | 16 +- tools/xml-sec-tools/src/xades/check.rs | 3 +- tools/xml-sec-tools/src/xades/corpus.rs | 1 + tools/xml-sec-tools/src/xades/dss.rs | 17 +- tools/xml-sec-tools/src/xades/fixtures.rs | 48 +- tools/xml-sec-tools/src/xades/levels.rs | 956 +++++++++++++++ tools/xml-sec-tools/src/xades/mod.rs | 4 +- tools/xml-sec-tools/src/xades/package.rs | 3 +- tools/xmlsec1/Cargo.toml | 4 +- vendor/sxd-document-no-unsafe/Cargo.toml | 2 +- 60 files changed, 6746 insertions(+), 180 deletions(-) create mode 100644 crates/xml-sec-xades/examples/level_probe.rs create mode 100644 crates/xml-sec-xades/src/accuracy.rs create mode 100644 crates/xml-sec-xades/src/level.rs create mode 100644 crates/xml-sec-xades/src/status.rs create mode 100644 crates/xml-sec-xades/tests/element.rs create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-t.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/detached.txt create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/issuer.der create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/outsider.der create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/root.der create mode 100644 crates/xml-sec-xades/tests/levels.rs create mode 100644 interop/xades/dss/src/main/java/LevelProbe.java create mode 100644 src/xmldsig/verify/session/element.rs create mode 100644 tools/xml-sec-tools/src/xades/levels.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 555ea49a..19312c9c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -285,6 +285,10 @@ jobs: cargo clippy -p xml-sec --lib --no-default-features --features cms,xml-backend-xmloxide --target thumbv7em-none-eabihf -- -D warnings + - run: >- + cargo clippy -p xml-sec-xades --lib --no-default-features + --features xml-backend-roxmltree + --target thumbv7em-none-eabihf -- -D warnings - uses: taiki-e/install-action@nextest - name: Target coverage on the build without std run: | diff --git a/Cargo.toml b/Cargo.toml index b48e4e60..d99ef43f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -299,11 +299,7 @@ snafu = { version = "0.9", default-features = false, features = ["rust_1_81"], o # Crypto cryptoki = { version = "0.12.1", optional = true } -# Keep the published consumer graph on bindgen 0.72: the newer sys release's -# bindgen 0.73 can resolve incompatible syn/prettyplease major versions. -# The sys dependency only constrains resolution; provider calls use aws-lc-rs. -aws-lc-rs = { version = "=1.18.2", default-features = false, features = ["fips"], optional = true } -aws-lc-fips-sys = { version = "=0.14.3", default-features = false, optional = true } +aws-lc-rs = { version = "1.19", default-features = false, features = ["fips"], optional = true } rsa = { package = "sad-rsa", version = "0.10.2", default-features = false, features = ["sha1", "sha2", "hazmat"], optional = true } sha1 = { version = "0.11", features = ["oid", "zeroize"], optional = true } sha2 = { version = "0.11", features = ["oid", "zeroize"], optional = true } @@ -356,10 +352,10 @@ pkcs12 = { version = "=0.2.0-pre.0", default-features = false, features = ["kdf" pbkdf2 = { version = "0.13", default-features = false, features = ["hmac"], optional = true } # X.509 certificates -structured-asn1 = { version = "0.18.2", default-features = false, features = ["alloc"], optional = true } -structured-pkix = { version = "0.18.2", default-features = false, features = ["alloc"], optional = true } +structured-asn1 = { version = "0.20.0", default-features = false, features = ["alloc"], optional = true } +structured-pkix = { version = "0.20.0", default-features = false, features = ["alloc"], optional = true } # PKCS#12 container framing; this crate keeps the password, KDF and cipher work. -structured-cms = { version = "0.18.2", default-features = false, features = ["alloc"], optional = true } +structured-cms = { version = "0.20.0", default-features = false, features = ["alloc"], optional = true } tinyvec = { version = "1.13", optional = true } # `pem` is RFC 7468 decoding of caller key and certificate text. der = { version = "0.8", default-features = false, features = ["alloc", "pem"], optional = true } @@ -427,7 +423,7 @@ std = [ "p384?/precomputed-tables", "p521?/precomputed-tables", ] -aws-lc-fips = ["std", "xmldsig", "dep:aws-lc-rs", "dep:aws-lc-fips-sys"] +aws-lc-fips = ["std", "xmldsig", "dep:aws-lc-rs"] pkcs11 = ["std", "xmlenc", "dep:cryptoki"] xml-backend-xmloxide = [] xml-backend-roxmltree = ["dep:memchr"] diff --git a/README.md b/README.md index 8e8f77b0..d5d903d1 100644 --- a/README.md +++ b/README.md @@ -12,10 +12,6 @@ Pure Rust XML Security for **XMLDSig**, **XML Encryption**, **C14N**, **SAML 2.0 **No C dependencies in the default build. No CMake. No system XML or crypto packages. Just `cargo add xml-sec`.** -> [!WARNING] -> Early-stage pre-release. The API is unstable, XMLDSig/XMLEnc coverage is still incomplete, -> and this crate should not yet be used in production. - ## Why xml-sec? - **End-to-end XML security**: sign, verify, encrypt, and decrypt through public Rust APIs. @@ -27,7 +23,7 @@ Just `cargo add xml-sec`.** Direct KEM-to-CBC additionally requires caller-owned external authentication; GCM is the safe default path. - **SAML-ready primitives**: enveloped signatures, encrypted assertions, X.509 keys, XPath, canonicalization, same-document XPointer references, DTD/`xml:id` IDs, and namespace-scoped ID registration. -- **Pure Rust deployment**: RustCrypto, `x509-parser`, and selectable Rust XML backends replace +- **Pure Rust deployment**: RustCrypto, shared structured PKIX/CMS primitives, and selectable Rust XML backends replace the libxml2/OpenSSL-style native dependency stack. - **Optional AWS-LC FIPS provider**: select a native cryptographic engine explicitly through the same provider contracts, without silent fallback to RustCrypto. @@ -69,13 +65,13 @@ declarations. Verification only, with no private-key import, password derivation or randomness source: ```toml -xml-sec = { version = "0.2", default-features = false, features = ["xmldsig", "c14n", "xml-backend-xmloxide"] } +xml-sec = { version = "0.4", default-features = false, features = ["xmldsig", "c14n", "xml-backend-xmloxide"] } ``` Verification and signing: ```toml -xml-sec = { version = "0.2", default-features = false, features = ["xmldsig-sign", "c14n", "xml-backend-xmloxide"] } +xml-sec = { version = "0.4", default-features = false, features = ["xmldsig-sign", "c14n", "xml-backend-xmloxide"] } ``` See [feature and provider qualification](docs/features.md) for supported combinations, @@ -95,7 +91,9 @@ a published dependency. C source and binary ABI compatibility are not delivered. | Optional XSLT transform | `xslt`: the XMLDSig XSLT transform on the safe-Rust XSLT 1.0 engine, without external resources and within operation-wide XSLT limits | | XML encryption | AES-CBC/GCM, RSA-OAEP, AES Key Wrap, opt-in Camellia-CBC/Key Wrap and experimental ChaCha20/Poly1305 profiles, ECDH/X25519/X448/DH, bounded KDFs, referenced ciphertext, nested recipients, and Element/Content replacement | | Optional compatibility algorithms | `legacy-algorithms`: MD5/RIPEMD-160 signatures and digests, AES-192, TripleDES-CBC/CMS wrap, and RSA-1.5 transport; library policy denies these by default | -| X.509 | Certificate key extraction, chain validation, CRLs, required key authorization by default, and typed trust evidence | +| XAdES | `xml-sec-xades`, an in-repository workspace crate: B-B, B-T, B-LT and B-LTA validation of verified signatures, including detached, parallel and countersigned ones, over the document's own timestamps and validation material; caller-supplied anchors, TSA policy accuracy, OCSP responders and status; nothing fetched | +| CMS | `cms`: the selected provider behind RFC 3161 timestamp and CMS signature checks | +| X.509 | Certificate key extraction, chain validation, complete and delta CRLs, required key authorization by default, and typed trust evidence | | Key management | Caller-owned named inventory, usage-restricted keys, xmlsec `keys.xml`, encrypted PKCS#8, and bounded RustCrypto-backed PKCS#12 import | | SAML 2.0 | Signed assertions and encrypted-assertion workflows covered by integration tests | | XML input | Strict bounded byte decoding, entity/depth/node limits, stable node identities, and generation-safe mutation | @@ -178,7 +176,7 @@ Use `xml-backend-roxmltree` for a thin alternative build, or compile `xml-backen `Xmloxide`, `Roxmltree`, or fail-closed `Differential` parsing per operation: ```toml -xml-sec = { version = "0.2", default-features = false, features = ["xmldsig", "xmlenc", "c14n", "xml-backends-all"] } +xml-sec = { version = "0.4", default-features = false, features = ["xmldsig", "xmlenc", "c14n", "xml-backends-all"] } ``` ```rust @@ -202,17 +200,6 @@ metadata. UTF-8 remains borrowed when possible; other supported encodings are st under the same materialization ceiling. Conflicting declarations, malformed byte sequences, ambiguous BOM-less UTF-16/UTF-32, and unsupported EBCDIC variants fail explicitly. -**API migration for this pre-release change:** `encoding::decode_xml_octets` now requires a -maximum decoded-byte count as its second argument. `encoding::XmlEncodingError` is now the -shared, non-exhaustive `xml_sec::encoding::XmlEncodingError`; update matches to handle the new error -variants and include a fallback arm. Code constructing `ResourcePolicy` with every field must -also set `max_xml_namespace_bindings` and the `max_xslt_*` limits (or start from -`ResourcePolicy::default()` and override selected fields); matches on `xmldsig::Transform` -need a fallback arm. These changes keep decoding and namespace-scope allocation under explicit -resource limits. For trusted resolver-provided encoding metadata, use -`xml_input::decode_xml_bounded(bytes, Some(encoding), maximum_decoded_bytes)`; the unbounded -decoder remains internal. - ## Native xmlsec1 CLI ```sh @@ -249,7 +236,9 @@ surface and operation behavior with source and test evidence. The [local XAdES interoperability corpus](interop/xades/README.md) compares exact Reference and SignedInfo bytes with native libxmlsec1 and checks independent EU DSS profile expectations. Its synthetic fixtures and reproducible commands distinguish transform/XMLDSig interoperability, -XAdES property binding, expected-object coverage, and trust-validation limits. +XAdES property binding, expected-object coverage, and trust-validation limits. Baseline levels +are compared with EU DSS conclusions on fixtures issued by OpenSSL, libxml2 and xmlsec1, and +checked on signatures DSS itself produced. ## Safe-Rust XSLT @@ -262,8 +251,8 @@ request host-clock compatibility. Resolver authorization also gates cached documents and retained stylesheet dependencies, with typed expiry/revocation failures that cannot be hidden by resource fallback. -The engine remains an in-repository workspace crate rather than a separately published package; -`xml-sec` is the only crate published to crates.io. Its optional `xslt` feature compiles the same +The engine remains an in-repository workspace crate rather than a separately published package, +as does `xml-sec-xades`; `xml-sec` is the only crate published to crates.io. Its optional `xslt` feature compiles the same engine sources and executes the XMLDSig XSLT transform with them; see [XML Digital Signatures](docs/xmldsig.md#xslt-transform). The shared strict byte-decoding and lexical source is compiled into `xml-sec` and reused by the internal XSLT workspace crate. @@ -278,6 +267,8 @@ lexical source is compiled into `xml-sec` and reused by the internal XSLT worksp | [XMLDSig 1.0/1.1](https://www.w3.org/TR/xmldsig-core1/) | Core sign/verify pipelines; complete Merlin, Phaos 3, XMLDSig 1.1, and Second Edition corpora classified and executed | | [XML Encryption](https://www.w3.org/TR/xmlenc-core1/) | Core AES-CBC/GCM, RSA-OAEP, and AES-KW pipelines implemented; broader conformance work continues | | [XSLT 1.0](https://www.w3.org/TR/xslt-10/) | Safe-Rust engine implemented; the XMLDSig XSLT transform executes with the optional `xslt` feature | +| [ETSI EN 319 132-1](https://www.etsi.org/deliver/etsi_en/319100_319199/31913201/01.03.01_60/en_31913201v010301p.pdf) (XAdES) | Baseline levels B-B to B-LTA validated through `xml-sec-xades`; signature creation is not provided | +| [RFC 3161](https://www.rfc-editor.org/rfc/rfc3161) | Timestamp tokens checked inside XAdES validation; no client or TSA | The project tracks stable Rust and supports Rust 1.92 or newer. Detailed contracts and limitations live in the [XMLDSig guide](docs/xmldsig.md), [XML Encryption guide](docs/xmlenc.md), and diff --git a/benchmarks/competitors/Cargo.lock b/benchmarks/competitors/Cargo.lock index 8fd6c629..8237309f 100644 --- a/benchmarks/competitors/Cargo.lock +++ b/benchmarks/competitors/Cargo.lock @@ -2453,9 +2453,9 @@ checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" [[package]] name = "structured-asn1" -version = "0.18.2" +version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1929d0c152f8c4f46777f01757d38df8dc0a8fd05dcf8ca5c1bc33ffe102d609" +checksum = "2327671666df0e22a40a20971a6eba300aeae791e363d71b074444e4c7f796d2" dependencies = [ "allocator-api2 0.2.21", "allocator-api2 0.4.0", @@ -2465,9 +2465,9 @@ dependencies = [ [[package]] name = "structured-cms" -version = "0.18.2" +version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c74074e07917756c831081389c342c7176c0399be4cbe966c0d5f23092c1a96" +checksum = "50f70a73d6891647a06c05534cc7436961c343c324499cea5b2eb090ce72354f" dependencies = [ "structured-asn1", "structured-pkix", @@ -2487,9 +2487,9 @@ dependencies = [ [[package]] name = "structured-pkix" -version = "0.18.2" +version = "0.20.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9e67176be19f5f1244c8c30021294c845a304b6189a8cf34b294a18b46a1b95" +checksum = "710a622e9d42ac36ff5d79030b141660d133fcbdcffc1bebf0f7d4c67c499efb" dependencies = [ "structured-asn1", "structured-email-address", diff --git a/crates/xml-sec-xades/Cargo.toml b/crates/xml-sec-xades/Cargo.toml index bcad2a14..4eaf1162 100644 --- a/crates/xml-sec-xades/Cargo.toml +++ b/crates/xml-sec-xades/Cargo.toml @@ -8,16 +8,28 @@ publish = false description = "XAdES baseline validation of signatures verified by xml-sec" [dependencies] -xml-sec = { path = "../..", default-features = false, features = ["std", "xmldsig", "c14n"] } -structured-xades = { version = "0.18.0", default-features = false, features = ["std"] } -structured-asn1 = { version = "0.18.0", default-features = false, features = ["std"] } -structured-pkix = { version = "0.18.0", default-features = false, features = ["std"] } -structured-cms = { version = "0.18.0", default-features = false, features = ["std"] } -structured-ltv = { version = "0.18.0", default-features = false, features = ["std"] } -thiserror = "2" +xml-sec = { path = "../..", default-features = false, features = ["xmldsig", "c14n", "cms"] } +structured-xades = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-asn1 = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-pkix = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-cms = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-ltv = { version = "0.20.0", default-features = false, features = ["alloc"] } +thiserror = { version = "2", default-features = false } + +[dev-dependencies] +base64 = "0.22" [features] -default = ["xml-backend-xmloxide"] +default = ["std", "xml-backend-xmloxide"] +std = [ + "xml-sec/std", + "structured-xades/std", + "structured-asn1/std", + "structured-pkix/std", + "structured-cms/std", + "structured-ltv/std", + "thiserror/std", +] xml-backend-xmloxide = ["xml-sec/xml-backend-xmloxide"] xml-backend-roxmltree = ["xml-sec/xml-backend-roxmltree"] diff --git a/crates/xml-sec-xades/examples/level_probe.rs b/crates/xml-sec-xades/examples/level_probe.rs new file mode 100644 index 00000000..fb2cecc9 --- /dev/null +++ b/crates/xml-sec-xades/examples/level_probe.rs @@ -0,0 +1,199 @@ +//! One baseline level of every signature of a document, through the public API. +//! +//! `level_probe XML ANCHOR_DER UNIX_TIME b|t|lt|lta [ACCURACY_SECONDS]`, where +//! `ANCHOR_DER` may be `-` to anchor where each chain the document carries ends, +//! and `ACCURACY_SECONDS` states that accuracy for the policy +//! of every token the document carries. Both are interoperability settings for +//! test corpora, never a trust decision. + +use std::convert::Infallible; +use std::sync::Arc; + +use base64::Engine as _; +use structured_asn1::memory::{Memory, MemoryAccount}; +use structured_asn1::{Oid, Parser}; +use structured_cms::timestamp::{Accuracy, PolicyAccuracy, Token}; +use structured_pkix::Certificate; +use structured_pkix::temporal::LeapTable; +use xml_sec::XmlDocument; +use xml_sec::policy::{Instant, VerificationPolicy}; +use xml_sec::xmldsig::{ + DefaultKeyResolver, KeyResolverConfig, VerificationRequest, VerifyContext, + with_verified_request, +}; +use xml_sec_xades::{ + AuthorityAccuracy, ConfiguredResponder, Inputs, Requirements, TokenProfile, validate, +}; + +/// Every base64 value between `open` and `close` in the source text. +fn values(text: &str, tag: &str) -> Vec> { + let mut found = Vec::new(); + for (start, _) in text.match_indices(tag) { + let closing = text[..start] + .rfind('<') + .is_some_and(|tag| text[tag..].starts_with("').filter(|_| !closing) else { + continue; + }; + let body = start + open + 1; + let Some(end) = text[body..].find('<') else { + continue; + }; + let compact: String = text[body..body + end] + .chars() + .filter(|character| !character.is_ascii_whitespace()) + .collect(); + if let Ok(value) = base64::engine::general_purpose::STANDARD.decode(compact) { + found.push(value); + } + } + found +} + +/// Where the chain of `certificate` ends among `pool`: it is self-issued, or +/// `pool` holds no other certificate naming its issuer. +fn terminal(certificate: &[u8], pool: &[Vec]) -> bool { + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 24, 1 << 28))); + let parser = Parser::der(account.clone()); + let Ok(parsed) = Certificate::read(&parser, certificate, 0) else { + return false; + }; + let issuer = parsed.tbs().issuer(); + let names = |other: &Certificate<'_>| { + other + .tbs() + .subject() + .matches(issuer, &account) + .unwrap_or(false) + }; + names(&parsed) + || !pool + .iter() + .filter(|other| other.as_slice() != certificate) + .filter_map(|other| Certificate::read(&parser, other, 0).ok()) + .any(|other| names(&other)) +} + +/// A DER certificate and a token's encoded policy identifier. +type Authority = (Vec, Vec); + +/// Each certificate a token or the document carries, with the token's policy. +fn token_authorities(text: &str, carried: &[Vec]) -> Result, String> { + let mut found = Vec::new(); + for token in values(text, "EncapsulatedTimeStamp") { + let parser = Parser::ber(Memory::new(Arc::new(MemoryAccount::new(1 << 24, 1 << 28)))); + let token = Token::read(&parser, &token, 0).map_err(|error| format!("{error:?}"))?; + let parent = parser.read(&[], 0).map_err(|error| format!("{error:?}"))?; + let policy = token + .with_info(&parent, |info, _, _| { + Ok::<_, Infallible>(info.policy().as_bytes().to_vec()) + }) + .map_err(|error| format!("{error:?}"))?; + let own = token.message().certificates().iter(); + for certificate in own.map(|parsed| parsed.as_bytes().to_vec()) { + found.push((certificate, policy.clone())); + } + for certificate in carried { + found.push((certificate.clone(), policy.clone())); + } + } + Ok(found) +} + +fn main() -> Result<(), Box> { + let args: Vec = std::env::args().collect(); + let [_, xml, anchor, at, level, rest @ ..] = &args[..] else { + return Err( + "usage: level_probe XML ANCHOR_DER|- UNIX_TIME b|t|lt|lta [ACCURACY_SECONDS [cms]]" + .into(), + ); + }; + let seconds = rest.first().map(|value| value.parse()).transpose()?; + let token_profile = match rest.get(1) { + Some(profile) if profile == "cms" => TokenProfile::Cms, + _ => TokenProfile::Etsi, + }; + let requirements = match level.as_str() { + "b" => Requirements::Basic, + "t" => Requirements::Timestamped, + "lt" => Requirements::LongTerm, + "lta" => Requirements::Archival, + _ => return Err("the level is b, t, lt or lta".into()), + }; + let text = std::fs::read_to_string(xml)?; + let carried = values(&text, "X509Certificate"); + let mut authorities = token_authorities(&text, &carried)?; + let mut pool = carried.clone(); + pool.extend( + authorities + .iter() + .map(|(certificate, _)| certificate.clone()), + ); + pool.sort(); + pool.dedup(); + let anchors: Vec> = if anchor == "-" { + pool.iter() + .filter(|c| terminal(c, &pool)) + .cloned() + .collect() + } else { + vec![std::fs::read(anchor)?] + }; + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: anchors.clone(), + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Instant::new(at.parse()?, 0); + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(text.as_str())?; + let request = VerificationRequest::default(); + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 27, 1 << 33))); + let utc = LeapTable::new(-2_208_988_800, 4_102_444_800, &[]) + .map_err(|error| format!("UTC coverage: {error:?}"))?; + let references: Vec<&[u8]> = anchors.iter().map(Vec::as_slice).collect(); + let others: Vec<&[u8]> = carried.iter().map(Vec::as_slice).collect(); + if seconds.is_none() { + authorities.clear(); + } + let mut responders = Vec::new(); + if seconds.is_some() { + for responder in &pool { + for issuer in &pool { + responders.push(ConfiguredResponder { responder, issuer }); + } + } + } + let mut accuracies = Vec::with_capacity(authorities.len()); + for (authority, policy) in &authorities { + let accuracy = Accuracy::new(seconds.unwrap_or_default(), 0, 0); + accuracies.push(AuthorityAccuracy { + authority, + stated: PolicyAccuracy::new(Oid::from_bytes(policy), accuracy) + .map_err(|error| error.to_string())?, + }); + } + with_verified_request(&document, &context, &request, &account, |session| { + for entry in session.evidence().signatures() { + println!("signature: {:?}", entry.result().as_ref().map(|r| r.status)); + let inputs = Inputs { + requirements, + token_profile, + anchors: &references, + certificates: &others, + utc: &utc, + accuracies: &accuracies, + responders: &responders, + crls: &[], + responses: &[], + }; + let outcome = validate(&session, entry.identity(), &inputs, |level| { + level.all_requirements_met() + }); + println!("level: {outcome:?}"); + } + Ok(()) + })?; + Ok(()) +} diff --git a/crates/xml-sec-xades/src/accuracy.rs b/crates/xml-sec-xades/src/accuracy.rs new file mode 100644 index 00000000..233eac38 --- /dev/null +++ b/crates/xml-sec-xades/src/accuracy.rs @@ -0,0 +1,87 @@ +//! Caller-established TSA policy accuracy, selected per token. + +use alloc::boxed::Box; +use core::convert::Infallible; + +use crate::{Error, ValidationError}; +use structured_asn1::memory::OwnedVec; +use structured_asn1::{Oid, Parser, Reader}; +use structured_cms::directory::{CertificateAgreement, matches_certificate_in}; +use structured_cms::timestamp::{PolicyAccuracy, Token}; +use structured_pkix::Certificate; +use xml_sec::xmldsig::X509ChainError; + +/// The accuracy one timestamp authority's policy states, for its tokens that +/// omit the field (RFC 3161 §2.4.2). The caller authenticates this association; +/// nothing in the document can supply or widen it. +#[derive(Clone, Copy)] +pub struct AuthorityAccuracy<'a> { + /// DER certificate of the timestamp authority. + pub authority: &'a [u8], + /// The signed policy identifier and the accuracy it states. + pub stated: PolicyAccuracy<'a>, +} + +/// One caller entry, its authority parsed once for the whole validation. +pub(crate) struct Stated<'s> { + authority: Certificate<'s>, + stated: PolicyAccuracy<'s>, +} + +/// Parse the caller's entries under the operation's certificate parser. +pub(crate) fn read<'s>( + parser: &'s Parser, + entries: &'s [AuthorityAccuracy<'s>], +) -> Result>, Error> { + let mut parsed = parser.memory().vector(); + parsed.try_reserve_exact(entries.len())?; + for entry in entries { + parsed.try_push(Stated { + authority: Certificate::read(parser, entry.authority, 0) + .map_err(X509ChainError::Processing)?, + stated: entry.stated, + })?; + } + Ok(parsed.into_owned()) +} + +/// The entry for the authority `token` names under its own signed `policy`. +/// Choosing by that policy keeps an unlisted one a completed negative fact +/// rather than the checker's refusal of a mismatched caller policy. +pub(crate) fn select<'s>( + stated: &[Stated<'s>], + token: &Token<'_>, + policy: Oid<'_>, + parent: &Reader<'s>, +) -> Result>, ValidationError> { + for entry in stated { + // The cheap policy comparison rejects before the directory comparison. + if policy != entry.stated.policy() { + continue; + } + let named = matches_certificate_in(token.signer().sid(), &entry.authority, parent) + .map_err(ValidationError::Token)?; + if matches!(named, CertificateAgreement::Matches) { + return Ok(Some(entry.stated)); + } + } + Ok(None) +} + +/// As [`select`], reading the policy of a token outside its information scope. +/// Nothing is read for a request that states no accuracy. +pub(crate) fn select_outside<'s>( + stated: &[Stated<'s>], + token: &Token<'_>, + token_reader: &Reader<'_>, + parent: &Reader<'s>, +) -> Result>, ValidationError> { + if stated.is_empty() { + return Ok(None); + } + token + .with_info(token_reader, |info, _, _| { + Ok::<_, Infallible>(select(stated, token, info.policy(), parent)) + }) + .map_err(|cause| ValidationError::TokenInfo(Box::new(cause)))? +} diff --git a/crates/xml-sec-xades/src/basic.rs b/crates/xml-sec-xades/src/basic.rs index bf42b6af..f4c54a38 100644 --- a/crates/xml-sec-xades/src/basic.rs +++ b/crates/xml-sec-xades/src/basic.rs @@ -1,18 +1,38 @@ //! The `XAdES` B-B pipeline for one verified signature. +use crate::accuracy::{self, AuthorityAccuracy, Stated}; +use crate::level::{RenewalFailure, TimestampFailure, signature_span}; use crate::path::{self, CounterPathError}; +use crate::status::{StatusError, StatusFailure}; use crate::{Document, Error}; +use alloc::{boxed::Box, string::String}; +use core::convert::Infallible; use structured_asn1::memory::Work; -use structured_xades::baseline::{self, Basic, BasicInput}; -use structured_xades::certificate::{self, KeyAssociation}; +use structured_asn1::{Parser, Reader}; +use structured_cms::content_source::ContentError; +use structured_cms::timestamp::InfoError; +use structured_ltv::baseline::{ArchiveCensusError, TimeError}; +use structured_ltv::material::IndexError; +use structured_ltv::pki::{ParticipantClosureError, ParticipantError, TimestampBindingError}; +use structured_ltv::timestamp::{ObligationError, TemporalError}; +use structured_pkix::temporal::{Instant, LeapTable}; +use structured_xades::baseline::{self, Basic, BasicInput, LevelError}; +use structured_xades::certificate::{self, CheckedPathCertificate, KeyAssociation}; use structured_xades::counter::{self, WalkError}; +use structured_xades::credential; use structured_xades::hashes::{self, HashError, ParticipantBinding, ParticipantProblem}; -use structured_xades::pki::{self, CounterSelectionError}; -use structured_xades::prepare; +use structured_xades::material::PipelineError; +use structured_xades::pki::{self, CounterPaths, CounterSelectionError}; +use structured_xades::prepare::{self, Prepared}; +use structured_xades::renewed; +use structured_xades::timestamp::{ + self, CarriedError, CounterTimestampError, RequirementError, TokenPipelineError, TokenProfile, +}; use structured_xades::unsigned::Requirements; use structured_xades::xml::{Access, Xml}; use xml_sec::document::{DocumentIdentity, NodeIdentity}; use xml_sec::xmldsig::VerifiedSession; +use xml_sec::xmldsig::cms::CmsProviderError; pub use crate::path::PathFailure; @@ -44,6 +64,27 @@ pub enum Outcome { /// An original actor used MD5 or an unsupported or unprocessed hash /// (EN 319 132-1 §6.2.1). Hashes(ParticipantProblem), + /// A timestamp token has no usable evidence for this request. + Timestamp { + /// Original timestamp property. + property: NodeIdentity, + /// Why the token proves nothing here. + failure: TimestampFailure, + }, + /// A signed credential has no selected format handler. + Credential { + /// Original credential payload. + node: NodeIdentity, + }, + /// A path member has no usable status input. + Status(StatusFailure), + /// A `RenewedDigestsV2` property does not confirm its detached object. + Renewal { + /// Original renewal property. + property: NodeIdentity, + /// Why it does not. + failure: RenewalFailure, + }, } /// Countersignature traversal failure with the original selection cause. @@ -81,8 +122,76 @@ pub enum ValidationError { /// The ASN.1 operation for binary values could not start. #[error("ASN.1 operation could not start: {0:?}")] Operation(structured_asn1::Error), + /// The stage reports do not describe the requested level. + #[error("baseline level assembly failed: {0:?}")] + Level(LevelError), + /// A countersignature's timestamp properties could not be read. + #[error("countersignature timestamps failed: {0:?}")] + Stamps(Box>), + /// Original timestamp tokens could not be decoded. + #[error("timestamp tokens failed: {0:?}")] + Tokens(Box>), + /// Original validation material could not be decoded. + #[error("validation material failed: {0:?}")] + Material(Box>), + /// A signature timestamp's generation time could not be read. + #[error("timestamp information failed: {0:?}")] + TokenInfo(Box>>), + /// A token's signer could not be compared with a certificate. + #[error("timestamp signer comparison failed: {0:?}")] + Token(structured_cms::directory::Error), + /// A timestamp check could not complete. + #[error("timestamp check failed: {0:?}")] + Timestamp(Box), + /// A token's generation interval could not be established. + #[error("timestamp generation interval failed: {0:?}")] + Time(TemporalError), + /// A token could not be bound to its checked path. + #[error("timestamp path binding failed: {0:?}")] + TimestampBinding(TimestampBindingError), + /// The document's timestamp obligations could not be derived. + #[error("timestamp requirements failed: {0:?}")] + Requirements(Box>), + /// The timestamp obligations could not be associated with their paths. + #[error("timestamp obligation failed: {0:?}")] + Obligation(ObligationError), + /// The B-T association could not complete. + #[error("timestamp association failed: {0:?}")] + Timing(TimeError), + /// A signed credential could not be processed. + #[error("credential processing failed: {0:?}")] + Credentials(Box>), + /// The participant census could not be derived or linked. + #[error("participant census failed: {0:?}")] + Participants(ParticipantError), + /// Material carried in a timestamp token could not be decoded. + #[error("carried token material failed: {0:?}")] + Carried(Box>), + /// The artifact index could not be built. + #[error("artifact index failed: {0:?}")] + Index(IndexError), + /// A path's status inputs could not be processed. + #[error("status processing failed: {0}")] + Status(Box), + /// The reachable status authorities could not be closed. + #[error("authority closure failed: {0:?}")] + Closure(ParticipantClosureError), + /// Material presence or placement could not be assessed. The cause borrows + /// certificates of this scope, so its diagnostic is what remains of it. + #[error("validation material assessment failed: {0}")] + Placement(String), + /// The archive census could not be completed. + #[error("archive census failed: {0:?}")] + Archives(ArchiveCensusError), + /// A `RenewedDigestsV2` property could not be processed. + #[error("renewed digest processing failed: {0:?}")] + Renewal(Box>), } +/// A timestamp check that could not complete, with its original cause. +pub type TimestampCheckError = + timestamp::CheckError; + /// Validate the B-B level (ETSI EN 319 132-1 §6.3) of `signature`. /// /// `signature` must be a Signature of `session`'s request. `certificates` @@ -108,13 +217,82 @@ pub fn validate_basic( signature: NodeIdentity, certificates: &[&[u8]], visitor: impl for<'a> FnOnce(&Report<'a>) -> R, +) -> Result, ValidationError> { + with_stage( + session, + signature, + Requirements::Basic, + [certificates, &[]], + None, + |_, report| Ok(Outcome::Assessed(visitor(report))), + ) +} + +/// The inputs a higher level continues from, all of one verified signature. +pub(crate) struct Stage<'a, 'view, 'scope, 'inputs, W: Work> { + pub(crate) session: &'a VerifiedSession<'view, 'scope, 'inputs, W>, + pub(crate) document: &'a Document<'a, 'view, 'scope, 'inputs, W>, + pub(crate) access: &'a Access<'a, Document<'a, 'view, 'scope, 'inputs, W>, W>, + pub(crate) prepared: &'a Prepared>, + pub(crate) counters: &'a CounterPaths<'a, 'a, NodeIdentity, DocumentIdentity, u64>, + pub(crate) certificate: &'a CheckedPathCertificate<'a, 'a, NodeIdentity, DocumentIdentity, u64>, + pub(crate) parser: &'a Parser, + pub(crate) operation: &'a Reader<'a>, + pub(crate) signer_time: Instant, + pub(crate) stated: &'a [Stated<'a>], + pub(crate) token_profile: TokenProfile, +} + +/// What a level above B-B reads timestamp tokens with. +#[derive(Clone, Copy)] +pub(crate) struct Timing<'t> { + pub(crate) utc: &'t LeapTable<'t>, + pub(crate) accuracies: &'t [AuthorityAccuracy<'t>], + pub(crate) profile: TokenProfile, +} + +/// The completed negative fact of a countersignature binding, or its refusal. +fn counter_fact(error: CounterError) -> Result, ValidationError> { + match error { + WalkError::Visitor(CounterSelectionError::Selection { + signature, + cause: CounterPathError::Missing(failure), + }) => Ok(Outcome::Path { signature, failure }), + WalkError::Visitor(CounterSelectionError::Differs { signature }) => { + Ok(Outcome::CounterKey { + signature, + association: KeyAssociation::Differs, + }) + } + WalkError::Visitor(CounterSelectionError::Unproven { signature }) => { + Ok(Outcome::CounterKey { + signature, + association: KeyAssociation::Unproven, + }) + } + error => Err(ValidationError::Counters(Box::new(error))), + } +} + +/// Run the B-B pipeline for the requested structural level, then `then` over +/// its assembled report. A completed negative fact stops before `then`. +pub(crate) fn with_stage( + session: &VerifiedSession<'_, '_, '_, W>, + signature: NodeIdentity, + requirements: Requirements, + certificates: [&[&[u8]]; 2], + timing: Option>, + then: impl for<'a> FnOnce( + &Stage<'a, '_, '_, '_, W>, + &Report<'a>, + ) -> Result, ValidationError>, ) -> Result, ValidationError> { let work = session.execution(); path::require_member(session, signature, work)?; let document = Document::new(session); let access = Access::new(&document, document.snapshot(), work); - let prepared = prepare::prepare(&access, signature, Requirements::Basic, None) + let prepared = prepare::prepare(&access, signature, requirements, None) .map_err(|error| ValidationError::Prepare(Box::new(error)))?; let fields = prepare::check_fields(&prepared, &access) .map_err(|error| ValidationError::Fields(Box::new(error)))?; @@ -129,18 +307,20 @@ pub fn validate_basic( let x509 = parser.memory(); let signers = path::signers(session, signature, &incorporated, x509)?; let decoded = path::key_info_certificates(session, &signers, x509)?; - let mut candidates = x509.vector(); - candidates - .try_reserve_exact(decoded.len() + certificates.len()) - .map_err(Error::from)?; - for bytes in &decoded { - candidates.try_push(&bytes[..]).map_err(Error::from)?; - } - for bytes in certificates { - candidates.try_push(*bytes).map_err(Error::from)?; - } + let candidates = path::candidates(&decoded, certificates, x509)?; let selection = path::select(&signers, &candidates, &parser, x509)?; - let paths = path::check(session, &selection, x509)?; + let operation = parser.read(&[], 0).map_err(ValidationError::Operation)?; + let verified_at = path::verification_time(&signers, signature); + let stated = accuracy::read(&parser, timing.map_or(&[], |timing| timing.accuracies))?; + let span = signature_span( + &document, + &prepared, + &operation, + &stated, + timing, + verified_at, + )?; + let paths = path::check(session, &selection, (signature, span), x509)?; let root = match paths.get(signature, x509) { Ok(root) => root, Err(CounterPathError::Missing(failure)) => { @@ -149,29 +329,12 @@ pub fn validate_basic( Err(CounterPathError::Resource(cause)) => return Err(Error::from(cause).into()), }; - let counters = match pki::bind_counters(prepared.bound(), &access, |binding, work| { + let bound = pki::bind_counters(prepared.bound(), &access, |binding, work| { paths.get(binding.original().child(), work) - }) { + }); + let counters = match bound { Ok(counters) => counters, - Err(WalkError::Visitor(CounterSelectionError::Selection { - signature, - cause: CounterPathError::Missing(failure), - })) => { - return Ok(Outcome::Path { signature, failure }); - } - Err(WalkError::Visitor(CounterSelectionError::Differs { signature })) => { - return Ok(Outcome::CounterKey { - signature, - association: KeyAssociation::Differs, - }); - } - Err(WalkError::Visitor(CounterSelectionError::Unproven { signature })) => { - return Ok(Outcome::CounterKey { - signature, - association: KeyAssociation::Unproven, - }); - } - Err(error) => return Err(ValidationError::Counters(Box::new(error))), + Err(error) => return counter_fact(error), }; let hashes = match hashes::check_participants(&prepared, &counters, &access) .map_err(|error| ValidationError::Hashes(Box::new(error)))? @@ -188,7 +351,6 @@ pub fn validate_basic( work, ) .map_err(|error| ValidationError::Certificate(Box::new(error)))?; - let operation = parser.read(&[], 0).map_err(ValidationError::Operation)?; let report = baseline::basic( BasicInput { fields: &fields, @@ -200,5 +362,21 @@ pub fn validate_basic( &operation, ) .map_err(|error| ValidationError::Basic(Box::new(error)))?; - Ok(Outcome::Assessed(visitor(&report))) + then( + &Stage { + session, + document: &document, + access: &access, + prepared: &prepared, + counters: &counters, + certificate: &certificate, + parser: &parser, + operation: &operation, + signer_time: verified_at.expect("a checked root path has its trust evidence"), + stated: &stated, + // B-B reads no token, so this choice is never consulted there. + token_profile: timing.map_or(TokenProfile::Etsi, |timing| timing.profile), + }, + &report, + ) } diff --git a/crates/xml-sec-xades/src/binary.rs b/crates/xml-sec-xades/src/binary.rs index f03e45f1..5cd8084f 100644 --- a/crates/xml-sec-xades/src/binary.rs +++ b/crates/xml-sec-xades/src/binary.rs @@ -5,9 +5,9 @@ use core::cmp::Ordering; use crate::signature::{MD5, any_uri}; use crate::{Document, Error, Snapshot}; use structured_asn1::digest::{Digest, Resolution}; -use structured_asn1::memory::Work; +use structured_asn1::memory::{OwnedVec, Work}; use structured_asn1::{Parser, Reader}; -use structured_xades::binary::{BinaryXml, Decoded}; +use structured_xades::binary::{BinaryXml, Decoded, OwnedBinaryXml, OwnedDecoded}; use structured_xades::certificate::DigestProvider; use structured_xades::hashes::HashClass; use structured_xades::xml::{Access, Name}; @@ -60,6 +60,40 @@ impl BinaryXml for Document<'_, '_, '_, '_, W> { } } +impl OwnedBinaryXml for Document<'_, '_, '_, '_, W> { + fn decode_owned( + &self, + snapshot: Snapshot, + node: NodeIdentity, + execution: &Q, + ) -> Result, Error> { + self.check(snapshot)?; + Ok(extension::base64_owned( + self.session.view(), + node, + execution, + )?) + } + + fn decode_binary_owned( + &self, + snapshot: Snapshot, + node: NodeIdentity, + operation: &Reader<'_>, + ) -> Result { + self.check(snapshot)?; + let bytes = extension::base64_owned(self.session.view(), node, &operation.execution())?; + // A fresh decoded source, as in `with_binary`: its producing session + // spends the operation's account. + Ok(OwnedDecoded { + parser: Parser::der(operation.memory().clone()), + bytes, + base: 0, + depth: 0, + }) + } +} + /// A resolved XML digest method of a signed certificate reference. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum DigestIdentity { diff --git a/crates/xml-sec-xades/src/level.rs b/crates/xml-sec-xades/src/level.rs new file mode 100644 index 00000000..2a6888f1 --- /dev/null +++ b/crates/xml-sec-xades/src/level.rs @@ -0,0 +1,1078 @@ +//! One requested baseline level over its complete linked stage reports. + +use alloc::{boxed::Box, format}; +use core::convert::Infallible; + +use crate::accuracy::{self, AuthorityAccuracy, Stated}; +use crate::basic::{Stage, Timing, ValidationError, with_stage}; +use crate::path::{self, Authorities, PathFailure}; +use crate::status::{self, StatusError}; +use crate::{Document, Error, Outcome, Report}; +use structured_asn1::memory::{Execution, Memory, OwnedVec, Work}; +use structured_asn1::{Parser, Reader}; +use structured_cms::directory::{CertificateAgreement, matches_certificate_in}; +use structured_cms::timestamp::{ + CheckContext, IntervalError, PolicyAccuracy, TokenExtension, interval_in, +}; +use structured_ltv::baseline::{self as composed, LongTerm, Timed}; +use structured_ltv::credential::Authentication; +use structured_ltv::material::Coverage; +use structured_ltv::pki::{ + AuthorityNode, CheckedPath, ParticipantAuthority, ParticipantRequirements, PathStatuses, + TimestampBinding, TimestampBindingFailure, TimestampPath, +}; +use structured_ltv::timestamp::{ + CheckedActor, TimestampPathBinding, TimestampPathFailure, TimestampPaths, + TimestampRequirements, Verified, +}; +use structured_pkix::Certificate; +use structured_pkix::crl::CertificateList; +use structured_pkix::ocsp::{BasicResponse, Response}; +use structured_pkix::path::{Anchor, Interval, WorkingKey}; +use structured_pkix::temporal::{Instant, LeapTable}; +use structured_xades::Xades; +use structured_xades::baseline::{self, Assessment, Evidence}; +use structured_xades::certificate::CheckedPathCertificate; +use structured_xades::credential::{self, ParticipantCredentials}; +use structured_xades::material::credentials::Scope; +use structured_xades::material::{self, Index, Value, View}; +use structured_xades::pki as xades_pki; +use structured_xades::prepare::Prepared; +use structured_xades::reference::VisitError; +use structured_xades::renewed::{self, PairCheck, PairOutcome}; +use structured_xades::timestamp::{ + self, CarriedMaterial, Check, Input, RequirementError, Role, TimestampSelection, TokenProfile, + TokenView, +}; +use structured_xades::unsigned::Requirements; +use structured_xades::xml::{Access, Xml}; +use xml_sec::document::{DocumentIdentity, NodeIdentity}; +use xml_sec::xmldsig::cms::CmsProvider; +use xml_sec::xmldsig::{VerifiedSession, X509ChainError}; + +type N = NodeIdentity; +type D = DocumentIdentity; +type G = u64; + +/// A signed credential's authentication receipt. No format is selected here, +/// so a document carrying one is refused rather than given an evidence value. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum NoCredential {} + +/// The stage reports of one requested level. Inspect their detailed findings: +/// [`Assessment::all_requirements_met`] states that the requested structure +/// holds, not that a status is usable, a chronology holds or a signer is trusted. +pub type Level<'a> = Assessment<'a, NoCredential, N, D, G>; + +/// Caller evidence of one baseline validation. Nothing here is discovered or +/// fetched: this is the whole outside world the validation sees. +#[derive(Clone, Copy)] +pub struct Inputs<'a> { + /// The structural level to establish. + pub requirements: Requirements, + /// How timestamp tokens are read. [`TokenProfile::Cms`] takes RFC 5652 BER, + /// so a met level then asserts nothing about EN 319 132-1 §5.1.3; + /// [`TokenProfile::Etsi`] holds each token to its declared encoding. + pub token_profile: TokenProfile, + /// DER certificates that end timestamp and revocation-authority paths. + pub anchors: &'a [&'a [u8]], + /// Further DER certificates a path may use, beyond the document's. + pub certificates: &'a [&'a [u8]], + /// Caller-authenticated UTC facts with explicit coverage. + pub utc: &'a LeapTable<'a>, + /// Policy accuracy of the authorities whose tokens omit the field. A token + /// neither stating accuracy nor listed here has no generation interval. + pub accuracies: &'a [AuthorityAccuracy<'a>], + /// OCSP responders the caller trusts for one issuer's certificates. + pub responders: &'a [ConfiguredResponder<'a>], + /// DER CRLs the caller obtained itself. They answer status, but only what + /// the document incorporates counts toward a level. + pub crls: &'a [&'a [u8]], + /// DER `OCSPResponse` values the caller obtained itself, read as `crls` are. + pub responses: &'a [&'a [u8]], +} + +/// Local configuration of an OCSP signing authority (RFC 6960 §4.2.2.2): this +/// responder answers for this issuer, without a delegation certificate. +#[derive(Clone, Copy)] +pub struct ConfiguredResponder<'a> { + /// DER certificate of the responder. + pub responder: &'a [u8], + /// DER certificate of the issuer it answers for. + pub issuer: &'a [u8], +} + +/// A timestamp token with no usable evidence for this request. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum TimestampFailure { + /// No available certificate is the one the token names as its signer. + MissingSigner, + /// The token's imprint, signature or profile facts did not hold. + Rejected, + /// The signer has no accepted path over the token's generation interval. + Path(PathFailure), + /// The checked path does not belong to the token's actual signer. + Binding(TimestampBindingFailure), + /// The checked paths do not answer every token of the document. + Census(TimestampPathFailure), +} + +/// Why a `RenewedDigestsV2` property does not confirm its detached object +/// (EN 319 132-1 §5.5.3). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum RenewalFailure { + /// The object's digest under the new algorithm differs from the declared one. + Differs, + /// No single detached `Manifest` reference matches the declared digest. + Unbound, + /// The property's digest method or `Manifest` cannot support a renewal. + Unusable, +} + +/// What the first unconfirmed pair of `report` says. +fn renewal_failure(pairs: &[PairCheck]) -> RenewalFailure { + let failed = pairs + .iter() + .find(|pair| !matches!(pair.outcome, PairOutcome::Matches)); + match failed.map(|pair| &pair.outcome) { + Some(PairOutcome::Differs) => RenewalFailure::Differs, + Some( + PairOutcome::MissingReference + | PairOutcome::AmbiguousReference + | PairOutcome::NotDetached, + ) => RenewalFailure::Unbound, + _ => RenewalFailure::Unusable, + } +} + +/// The first `RenewedDigestsV2` property that does not confirm its object. +fn unconfirmed_renewal( + stage: &Stage<'_, '_, '_, '_, W>, +) -> Result, ValidationError> { + let renewals = renewed::check_prepared( + stage.document, + stage.prepared, + stage.document, + stage.session.execution(), + ) + .map_err(|error| ValidationError::Renewal(Box::new(error)))?; + let report = renewals.reports().iter().find(|report| !report.agrees()); + Ok(report.map(|report| (report.property(), renewal_failure(report.pairs())))) +} + +/// Validate the requested baseline level (ETSI EN 319 132-1 §6.3) of `signature`. +/// +/// The visitor receives the level's reports; nothing borrowed from them can +/// escape. All limits come from the session's compiled policy. +/// +/// # Errors +/// Returns the original cause of the stage that could not complete. +pub fn validate( + session: &VerifiedSession<'_, '_, '_, W>, + signature: N, + inputs: &Inputs<'_>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let requirements = inputs.requirements; + let timing = (requirements != Requirements::Basic).then_some(Timing { + utc: inputs.utc, + accuracies: inputs.accuracies, + profile: inputs.token_profile, + }); + with_stage( + session, + signature, + requirements, + // Verification's own path may end at any of them or pass through any of + // them; only `anchors` end the paths this validation builds itself. + [inputs.anchors, inputs.certificates], + timing, + |stage, basic| { + if requirements == Requirements::Basic { + let level = + baseline::assess(Evidence::Basic(basic)).map_err(ValidationError::Level)?; + return Ok(Outcome::Assessed(visitor(&level))); + } + timed(stage, basic, inputs, visitor) + }, + ) +} + +type TokenActor<'c, 'd> = CheckedActor<'c, 'd, N, D, G, Xades>; +type TsaPath<'v, 'c, 'd> = TimestampPath<'v, 'c, 'd, N, D, G, Xades>; +type Stamps = timestamp::CounterTimestamps; +type Tokens<'s> = TokenView<'s, N, D, G>; +type Material<'s> = View<'s, N, D, G>; +type Required = TimestampRequirements; +type Actors<'a> = ParticipantRequirements<'a, 'a, N, D, G, Xades>; +type Credentials<'a> = ParticipantCredentials<'a, 'a, NoCredential, N, D, G>; +type TimedReport<'a> = + Timed<'a, 'a, 'a, Report<'a>, CheckedPathCertificate<'a, 'a, N, D, G>, N, D, G, Xades>; +type LongTermReport<'a> = LongTerm< + 'a, + TimedReport<'a>, + material::Checks<'a, 'a, 'a, 'a, 'a, N, D, G>, + material::credentials::Report<'a, 'a, 'a, NoCredential, N, D, G>, +>; + +/// The token and material pools, frozen for the rest of the validation. +struct Pools<'p, 't> { + stamps: &'p Stamps, + operation: &'p Reader<'t>, + tokens: &'p Tokens<'t>, + view: &'p Material<'t>, +} + +fn timed( + stage: &Stage<'_, '_, '_, '_, W>, + basic: &Report<'_>, + inputs: &Inputs<'_>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let stamps = timestamp::counter_timestamps(stage.access, stage.counters) + .map_err(|error| ValidationError::Stamps(Box::new(error)))?; + timestamp::with_counter_tokens( + stage.document, + stage.prepared, + &stamps, + stage.operation, + stage.token_profile, + |operation, tokens| { + Ok::<_, Infallible>( + material::with_counter_values( + stage.document, + stage.prepared, + stage.counters, + operation, + |operation, view| { + let pools = Pools { + stamps: &stamps, + operation, + tokens: &tokens, + view: &view, + }; + Ok::<_, Infallible>(frozen(stage, basic, inputs, &pools, visitor)) + }, + ) + .map_err(|error| ValidationError::Material(Box::new(error))) + .and_then(core::convert::identity), + ) + }, + ) + .map_err(|error| ValidationError::Tokens(Box::new(error)))? +} + +/// Every certificate a path may use, whatever carried it. Being here proves +/// nothing: a path still has to end at a caller anchor. +fn certificate_pool<'p, 't>( + pools: &'p Pools<'p, 't>, + supplied: &'p [Certificate<'t>], + memory: &Memory, +) -> Result>, Error> { + let mut pool = memory.vector(); + for value in pools.view.values() { + if let Value::Certificate(certificate) = &value.value { + pool.try_push(certificate)?; + } + } + for basic in pools.view.basic_responses() { + for certificate in basic.response().certificates() { + pool.try_push(certificate)?; + } + } + for reading in pools.tokens.readings() { + for certificate in reading.token().message().certificates() { + pool.try_push(certificate)?; + } + } + for certificate in supplied { + pool.try_push(certificate)?; + } + Ok(pool.into_owned()) +} + +/// A completed negative fact about one timestamp property. +type TokenFailure = (N, TimestampFailure); + +/// The certificate token `ordinal` names as its signer, with its own reader. +fn token_signer<'p, 't>( + pools: &'p Pools<'p, 't>, + ordinal: usize, + supplied: &'p [Certificate<'t>], + supplied_parent: &'p Reader<'t>, +) -> Result, &'p Reader<'t>)>, ValidationError> { + let reading = &pools.tokens.readings()[ordinal]; + let named = reading.token().signer().sid(); + let carried = reading.token().message().certificates(); + for (certificates, parent) in [(carried, reading.reader()), (supplied, supplied_parent)] { + for certificate in certificates { + if matches!( + matches_certificate_in(named, certificate, parent) + .map_err(ValidationError::Token)?, + CertificateAgreement::Matches + ) { + return Ok(Some((certificate, parent))); + } + } + } + Ok(None) +} + +/// No token extension is recognized, so a critical one refuses its token. +fn unrecognized() -> impl FnMut(&TokenExtension<'_>, &Execution<'_>) -> Result { + |_, _| Ok(false) +} + +/// Check every token of the document with its named signer's own key. +fn token_actors<'p, 't, W: Work>( + stage: &'p Stage<'_, '_, '_, '_, W>, + inputs: &'p Inputs<'t>, + pools: &'p Pools<'p, 't>, + supplied: &'p [Certificate<'t>], + supplied_parent: &'p Reader<'t>, + cms: &CmsProvider<'_>, +) -> Result>, TokenFailure>, ValidationError> { + let Pools { + stamps, + operation, + tokens, + .. + } = *pools; + let roots = stage.prepared.timestamps(); + let mut actors = stage.parser.memory().vector(); + actors + .try_reserve_exact(tokens.sources().len()) + .map_err(Error::from)?; + for ordinal in 0..tokens.sources().len() { + let source = &tokens.sources()[ordinal]; + let Some((certificate, parent)) = token_signer(pools, ordinal, supplied, supplied_parent)? + else { + return Ok(Err((source.property(), TimestampFailure::MissingSigner))); + }; + let reading = &tokens.readings()[ordinal]; + let policy_accuracy = accuracy::select_outside( + stage.stated, + reading.token(), + reading.reader(), + stage.operation, + )?; + let context = CheckContext { + certificate, + certificate_parent: parent, + key: WorkingKey::standing(certificate.tbs().public_key()), + // An incorporated token is archived evidence: this instant only + // refuses one generated after the time being validated at. + requested: None, + utc: inputs.utc, + reference: Some(stage.signer_time), + window: None, + policy_accuracy, + }; + let check = Check { + xml: stage.document, + provider: cms, + context: &context, + }; + let actor = if let Some(stamp) = roots.get(source.stamp_index()) { + check.retain_actor( + stage.prepared.bound(), + stamp, + source.token_index(), + operation, + unrecognized(), + ) + } else { + let counter = &stamps.entries()[source.stamp_index() - roots.len()]; + let entry = tokens.entry(ordinal).expect("ordinal within the pool"); + check.retain_counter_from(counter, entry, operation, unrecognized()) + } + .map_err(|error| ValidationError::Timestamp(Box::new(error)))?; + let Some(actor) = actor else { + return Ok(Err((source.property(), TimestampFailure::Rejected))); + }; + actors.try_push(actor).map_err(Error::from)?; + } + Ok(Ok(actors.into_owned())) +} + +/// Each actor's path over its token's whole stated generation interval. +fn actor_paths<'d, W: Work>( + session: &VerifiedSession<'_, '_, '_, W>, + authorities: &Authorities<'d>, + actors: &'d [TokenActor<'d, 'd>], + utc: &LeapTable<'_>, +) -> Result>, TokenFailure>, ValidationError> { + let memory = authorities.memory; + let mut checked = memory.vector(); + checked + .try_reserve_exact(actors.len()) + .map_err(Error::from)?; + for actor in actors { + let generation = actor + .verified() + .interval(utc, memory) + .map_err(ValidationError::Time)?; + let interval = Interval::between_instants(generation.earliest, generation.latest); + match path::discover(session, authorities, actor.certificate(), interval)? { + Ok(path) => checked.try_push(path).map_err(Error::from)?, + Err(failure) => { + let property = actor.verified().property(); + return Ok(Err((property, TimestampFailure::Path(failure)))); + } + } + } + Ok(Ok(checked.into_owned())) +} + +/// The checked paths bound to the very tokens they answer. +fn bound_paths<'v, 'd>( + checked: &'v [CheckedPath<'d>], + actors: &'v [TokenActor<'d, 'd>], + utc: &LeapTable<'_>, + memory: &Memory, +) -> Result>, TokenFailure>, ValidationError> { + let mut bound = memory.vector(); + bound.try_reserve_exact(actors.len()).map_err(Error::from)?; + for (path, actor) in checked.iter().zip(actors) { + match path + .bind_timestamp(actor, utc, memory) + .map_err(ValidationError::TimestampBinding)? + { + TimestampBinding::Bound(value) => bound.try_push(value).map_err(Error::from)?, + TimestampBinding::Rejected(cause) => { + let property = actor.verified().property(); + return Ok(Err((property, TimestampFailure::Binding(cause)))); + } + } + } + Ok(Ok(bound.into_owned())) +} + +/// Early return of a completed negative token fact. +macro_rules! token_fact { + ($value:expr) => { + match $value? { + Ok(value) => value, + Err((property, failure)) => return Ok(Outcome::Timestamp { property, failure }), + } + }; +} + +fn frozen( + stage: &Stage<'_, '_, '_, '_, W>, + basic: &Report<'_>, + inputs: &Inputs<'_>, + pools: &Pools<'_, '_>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let session = stage.session; + let memory = stage.parser.memory(); + let access = stage.access; + let anchors = read_certificates(stage.parser, inputs.anchors)?; + let supplied = read_certificates(stage.parser, inputs.certificates)?; + let supplied_parent = stage + .parser + .read(&[], 0) + .map_err(ValidationError::Operation)?; + let pool = certificate_pool(pools, &supplied, memory)?; + let mut anchored = memory.vector(); + anchored + .try_reserve_exact(anchors.len()) + .map_err(Error::from)?; + for anchor in &anchors { + anchored + .try_push(Anchor::from_certificate(anchor)) + .map_err(Error::from)?; + } + let authorities = Authorities { + anchors: &anchors, + anchored: &anchored, + pool: &pool, + responders: inputs.responders, + memory, + }; + let external = External::read(stage.parser, inputs, &supplied_parent)?; + let cms = session.cms_provider(); + let actors = token_fact!(token_actors( + stage, + inputs, + pools, + &supplied, + &supplied_parent, + &cms + )); + let checked = token_fact!(actor_paths(session, &authorities, &actors, inputs.utc)); + let bound = token_fact!(bound_paths(&checked, &actors, inputs.utc, memory)); + let mut references = memory.vector(); + references + .try_reserve_exact(bound.len()) + .map_err(Error::from)?; + for path in &bound { + references.try_push(path).map_err(Error::from)?; + } + let whole = timestamp::requirements_with_counters( + access, + stage.prepared, + pools.stamps, + TimestampSelection::All, + ) + .map_err(|error| ValidationError::Requirements(Box::new(error)))?; + let paths = match whole + .bind_paths(&references, access) + .map_err(ValidationError::Obligation)? + { + TimestampPathBinding::Bound(paths) => paths, + TimestampPathBinding::Unproven(cause) => { + return Ok(Outcome::Timestamp { + property: whole.signature(), + failure: TimestampFailure::Census(cause), + }); + } + }; + let timed = composed::timestamped(basic, &paths, access).map_err(ValidationError::Timing)?; + if inputs.requirements == Requirements::Timestamped { + let level = + baseline::assess(Evidence::Timestamped(&timed)).map_err(ValidationError::Level)?; + return Ok(Outcome::Assessed(visitor(&level))); + } + long_term( + &Chain { + stage, + inputs, + pools, + authorities: &authorities, + external: &external, + cms: &cms, + bound: &bound, + paths: &paths, + timed: &timed, + }, + visitor, + ) +} + +/// Everything the long-term stages share. +struct Chain<'c, 'a, 'v, 's, 'i, 't, W: Work> { + stage: &'c Stage<'a, 'v, 's, 'i, W>, + inputs: &'c Inputs<'c>, + pools: &'c Pools<'c, 't>, + authorities: &'c Authorities<'c>, + external: &'c External<'c>, + cms: &'c CmsProvider<'c>, + bound: &'c [TsaPath<'c, 'c, 'c>], + paths: &'c TimestampPaths<'c, 'c, 'c, N, D, G, Xades>, + timed: &'c TimedReport<'c>, +} + +/// The status sources the caller supplied, parsed once. +struct External<'s> { + crls: OwnedVec>, + responses: OwnedVec>, +} + +impl<'s> External<'s> { + fn read( + parser: &'s Parser, + inputs: &Inputs<'s>, + query: &Reader<'s>, + ) -> Result { + let status = |cause: structured_pkix::Error| { + ValidationError::Status(Box::new(StatusError::Pkix(cause))) + }; + let (mut crls, mut responses) = (parser.memory().vector(), parser.memory().vector()); + crls.try_reserve_exact(inputs.crls.len()) + .map_err(Error::from)?; + for bytes in inputs.crls { + let list = CertificateList::read(parser, bytes, 0).map_err(status)?; + crls.try_push(list).map_err(Error::from)?; + } + for bytes in inputs.responses { + // A protocol failure carries no signed status, so it answers nothing. + let Response::Successful(body) = Response::read(parser, bytes, 0).map_err(status)? + else { + continue; + }; + if let Some(basic) = body.basic_in(query).map_err(status)? { + responses.try_push(basic).map_err(Error::from)?; + } + } + Ok(Self { + crls: crls.into_owned(), + responses: responses.into_owned(), + }) + } +} + +/// The CRLs and OCSP responses of one document, then the caller's. +fn status_sources<'p, 't: 'p>( + view: &'p Material<'t>, + carried: &'p CarriedMaterial<'t, N, D, G>, + external: &'p External<'t>, + memory: &Memory, +) -> Result< + ( + OwnedVec<&'p CertificateList<'t>>, + OwnedVec<&'p BasicResponse<'t>>, + ), + Error, +> { + let mut lists = memory.vector(); + for value in view.values() { + if let Value::Crl(list) = &value.value { + lists.try_push(list)?; + } + } + for list in carried.crls() { + lists.try_push(&list.value)?; + } + for list in &*external.crls { + lists.try_push(list)?; + } + let mut responses = memory.vector(); + for basic in view.basic_responses() { + responses.try_push(basic.response())?; + } + for response in carried.basic_responses() { + responses.try_push(&response.value)?; + } + for response in &*external.responses { + responses.try_push(response)?; + } + Ok((lists.into_owned(), responses.into_owned())) +} + +/// Every participant's status, its incorporation and, for B-LTA, each archive. +fn long_term( + chain: &Chain<'_, '_, '_, '_, '_, '_, W>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let stage = chain.stage; + let access = stage.access; + let memory = stage.parser.memory(); + let credentials = + match credential::check_participants(stage.prepared, stage.counters, &NoFormats, access) { + Ok(credentials) => credentials, + Err(credential::Error::Unsupported { node }) => { + return Ok(Outcome::Credential { node }); + } + Err(error) => return Err(ValidationError::Credentials(Box::new(error))), + }; + let participants = xades_pki::participants( + stage.certificate, + stage.counters, + &credentials, + chain.paths, + access, + ) + .map_err(ValidationError::Participants)?; + let carried = chain + .pools + .tokens + .material_in(chain.pools.operation) + .map_err(|error| ValidationError::Carried(Box::new(error)))?; + let index = material::index_with_tokens(chain.pools.view, &carried, access) + .map_err(ValidationError::Index)?; + let (lists, responses) = status_sources(chain.pools.view, &carried, chain.external, memory)?; + // One census per live path; several actors may share one. + let mut distinct: OwnedVec<&CheckedPath<'_>, _> = memory.vector(); + for path in participant_paths(&participants) { + if !distinct.iter().any(|known| core::ptr::eq(*known, path)) { + distinct.try_push(path).map_err(Error::from)?; + } + } + let closed = status::with_statuses( + stage.session, + chain.cms, + chain.authorities, + &lists, + &responses, + &distinct, + chain.inputs.utc, + stage.signer_time, + |statuses, nodes| { + material_level( + chain, + &Assessed { + credentials: &credentials, + participants: &participants, + index: &index, + statuses, + nodes, + }, + visitor, + ) + }, + ) + .map_err(|error| ValidationError::Status(Box::new(error)))?; + match closed { + Ok(outcome) => outcome, + Err(failure) => Ok(Outcome::Status(failure)), + } +} + +/// The whole-signature facts every long-term report is derived from. +struct Assessed<'a, W: Work> { + credentials: &'a Credentials<'a>, + participants: &'a Actors<'a>, + index: &'a Index<'a, N, D, G, W>, + statuses: &'a [&'a PathStatuses<'a, 'a, 'a>], + nodes: &'a [AuthorityNode<'a, 'a, 'a>], +} + +fn placement_error(error: impl core::fmt::Debug) -> ValidationError { + ValidationError::Placement(format!("{error:?}")) +} + +/// The B-LT reports, and the B-LTA census when the request asks for it. +fn material_level( + chain: &Chain<'_, '_, '_, '_, '_, '_, W>, + facts: &Assessed<'_, W>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let stage = chain.stage; + let access = stage.access; + let roots = census(facts.participants, facts.statuses, stage.parser.memory())?; + let closure = facts + .participants + .close_statuses(&roots, facts.nodes, access) + .map_err(ValidationError::Closure)?; + let x509 = material::check_participants( + stage.prepared, + &closure, + stage.counters, + facts.index, + access, + ) + .map_err(placement_error)?; + let format = material::credentials::check( + facts.credentials, + stage.counters, + chain.paths.required(), + facts.index, + &Scope::whole(), + &NoFormats, + access, + ) + .map_err(placement_error)?; + let long_term = composed::long_term(chain.timed, &x509, &format, access) + .map_err(ValidationError::Participants)?; + if chain.inputs.requirements == Requirements::LongTerm { + let level = + baseline::assess(Evidence::LongTerm(&long_term)).map_err(ValidationError::Level)?; + return Ok(Outcome::Assessed(visitor(&level))); + } + archival(chain, facts, &long_term, visitor) +} + +type EarlierScopes<'c> = ( + OwnedVec, + OwnedVec>>, +); + +/// Each archive's earlier token scope, and the checked paths of those tokens. +fn earlier_scopes<'c, W: Work>( + chain: &Chain<'c, '_, '_, '_, '_, '_, W>, + archives: &[usize], +) -> Result, TokenFailure>, ValidationError> { + let stage = chain.stage; + let memory = stage.parser.memory(); + let (mut earlier, mut chosen) = (memory.vector(), memory.vector()); + for ordinal in archives { + let required = timestamp::requirements_with_counters( + stage.access, + stage.prepared, + chain.pools.stamps, + TimestampSelection::BeforeArchive(*ordinal), + ) + .map_err(|error| ValidationError::Requirements(Box::new(error)))?; + let mut paths = memory.vector(); + for entry in required.entries() { + let Some(path) = chain + .bound + .iter() + .find(|path| path.actor().verified().token().node == entry.token) + else { + let failure = TimestampFailure::Census(TimestampPathFailure::Count); + return Ok(Err((entry.property, failure))); + }; + paths.try_push(path).map_err(Error::from)?; + } + chosen.try_push(paths.into_owned()).map_err(Error::from)?; + earlier.try_push(required).map_err(Error::from)?; + } + Ok(Ok((earlier.into_owned(), chosen.into_owned()))) +} + +type ArchiveInput<'c> = ( + Coverage, + &'c Verified, +); + +/// Each archive's exact input coverage and its checked token. +fn archive_inputs<'c, W: Work>( + chain: &Chain<'c, '_, '_, '_, '_, '_, W>, + archives: &[usize], +) -> Result>, ValidationError> { + let stage = chain.stage; + let memory = stage.parser.memory(); + let mut covered = memory.vector(); + for ordinal in archives { + let stamp = &stage.prepared.timestamps()[*ordinal]; + let input = Input::prepare(stage.document, stage.prepared.bound(), stamp, memory) + .map_err(|error| ValidationError::Requirements(Box::new(error.into())))?; + let coverage = input.element_coverage(memory).map_err(|error| { + ValidationError::Requirements(Box::new(RequirementError::Coverage(error))) + })?; + let evidence = chain + .bound + .iter() + .map(|path| path.actor().verified()) + .find(|verified| verified.property() == stamp.node()) + .expect("every archive token has its checked path"); + covered + .try_push((coverage, evidence)) + .map_err(Error::from)?; + } + Ok(covered.into_owned()) +} + +/// The census of every root archive, each over its own earlier scope. +fn archival( + chain: &Chain<'_, '_, '_, '_, '_, '_, W>, + facts: &Assessed<'_, W>, + long_term: &LongTermReport<'_>, + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError> { + let stage = chain.stage; + let (access, memory) = (stage.access, stage.parser.memory()); + let mut archives = memory.vector(); + for (ordinal, stamp) in stage.prepared.timestamps().iter().enumerate() { + if stamp.role() == Role::Archive { + archives.try_push(ordinal).map_err(Error::from)?; + } + } + let (earlier, chosen) = token_fact!(earlier_scopes(chain, &archives)); + let mut prior = memory.vector(); + for (required, paths) in earlier.iter().zip(chosen.iter()) { + match required + .bind_paths(paths, access) + .map_err(ValidationError::Obligation)? + { + TimestampPathBinding::Bound(value) => prior.try_push(value).map_err(Error::from)?, + TimestampPathBinding::Unproven(cause) => { + return Ok(Outcome::Timestamp { + property: required.signature(), + failure: TimestampFailure::Census(cause), + }); + } + } + } + let (mut actors, mut censuses) = (memory.vector(), memory.vector()); + for paths in &prior { + let scope = xades_pki::participants( + stage.certificate, + stage.counters, + facts.credentials, + paths, + access, + ) + .map_err(ValidationError::Participants)?; + censuses + .try_push(census(&scope, facts.statuses, memory)?) + .map_err(Error::from)?; + actors.try_push(scope).map_err(Error::from)?; + } + let mut closures = memory.vector(); + for (actors, roots) in actors.iter().zip(censuses.iter()) { + let closure = actors + .close_statuses(roots, facts.nodes, access) + .map_err(ValidationError::Closure)?; + closures.try_push(closure).map_err(Error::from)?; + } + let covered = archive_inputs(chain, &archives)?; + let (mut x509, mut formats) = (memory.vector(), memory.vector()); + for ((closure, required), (coverage, evidence)) in + closures.iter().zip(earlier.iter()).zip(covered.iter()) + { + let material = structured_ltv::material::archived_participants( + closure, + facts.index, + coverage, + *evidence, + access, + ) + .map_err(placement_error)?; + x509.try_push(material).map_err(Error::from)?; + let format = material::credentials::check( + facts.credentials, + stage.counters, + required, + facts.index, + &Scope::before_archive(coverage, evidence), + &NoFormats, + access, + ) + .map_err(placement_error)?; + formats.try_push(format).map_err(Error::from)?; + } + let mut pairs = memory.vector(); + for (material, format) in x509.iter().zip(formats.iter()) { + let pair = composed::archive_material(material, format, access) + .map_err(ValidationError::Participants)?; + pairs.try_push(pair).map_err(Error::from)?; + } + let mut reports = memory.vector(); + for pair in &pairs { + reports.try_push(pair).map_err(Error::from)?; + } + let archives = + composed::archives(stage.prepared, &reports, access).map_err(ValidationError::Archives)?; + if let Some((property, failure)) = unconfirmed_renewal(stage)? { + return Ok(Outcome::Renewal { property, failure }); + } + let level = baseline::assess(Evidence::Archival { + long_term, + archives: &archives, + }) + .map_err(ValidationError::Level)?; + Ok(Outcome::Assessed(visitor(&level))) +} + +/// The checked path of every path actor of `participants`, in census order. +fn participant_paths<'p, 'd>( + participants: &'p ParticipantRequirements<'p, 'd, N, D, G, Xades>, +) -> impl Iterator> { + participants + .entries() + .iter() + .filter_map(|entry| match entry.authority() { + ParticipantAuthority::Path(path) => Some(path), + ParticipantAuthority::Anchor(_) | ParticipantAuthority::CertificateFree => None, + }) +} + +/// One root census per path actor, in the order `close_statuses` requires. +fn census<'v, 'c, 'd>( + participants: &ParticipantRequirements<'_, 'd, N, D, G, Xades>, + statuses: &[&'v PathStatuses<'v, 'c, 'd>], + memory: &Memory, +) -> Result>, ValidationError> { + let mut roots = memory.vector(); + for path in participant_paths(participants) { + let status = statuses + .iter() + .find(|status| core::ptr::eq(status.path(), path)) + .expect("every distinct actor path has its census"); + roots.try_push(*status).map_err(Error::from)?; + } + Ok(roots.into_owned()) +} + +/// No credential format is selected, so every signed one stays unsupported. +struct NoFormats; + +impl<'p, 'd, X: Xml> credential::Provider<'p, 'd, X> for NoFormats { + type Evidence = NoCredential; + type Error = Infallible; + + fn authenticate( + &self, + _access: &Access<'_, X, Q>, + _credential: credential::Credential, + ) -> Result, Infallible> { + Ok(Authentication::Unsupported) + } +} + +impl material::credentials::Provider for NoFormats { + type Error = Infallible; + + fn visit( + &self, + credential: &credential::Checked<'_, '_, NoCredential, X::Id, X::Document, X::Generation>, + _open: &[material::Opaque], + _access: &Access<'_, X, Q>, + _visitor: impl for<'value, 'document> FnMut( + material::credentials::Need<'value, 'document, X::Id, X::Document, X::Generation>, + ) -> Result<(), VE>, + ) -> Result> { + match *credential.evidence() {} + } +} + +/// The interval the signer's path must hold over: the verification instant and +/// every signature timestamp's whole stated generation interval (EN 319 132-1 +/// V1.3.1 §6.3(o)). Read before any token is authenticated, which is safe in one +/// direction only: a false time widens what the path must satisfy, and the +/// association itself uses the authenticated token. A token whose accuracy +/// neither it nor the caller states adds nothing here and stays unproven there. +pub(crate) fn signature_span<'s, W: Work>( + document: &Document<'_, '_, '_, '_, W>, + prepared: &Prepared>, + operation: &Reader<'s>, + stated: &[Stated<'s>], + timing: Option>, + verified_at: Option, +) -> Result, ValidationError> { + let (Some(Timing { utc, profile, .. }), Some(at)) = (timing, verified_at) else { + return Ok(None); + }; + let parent = operation; + let span = timestamp::with_tokens( + document, + prepared, + operation, + profile, + |operation, tokens| { + let execution = operation.execution(); + let (mut first, mut last) = (at, at); + for (source, reading) in tokens.sources().iter().zip(tokens.readings()) { + if source.role() != Role::Signature { + continue; + } + let generation = reading.token().with_info(reading.reader(), |info, _, _| { + // RFC 3161 §2.4.2: policy accuracy answers only an absent field. + let accuracy = match info.accuracy() { + Some(value) => value.deviation().ok(), + None => { + match accuracy::select(stated, reading.token(), info.policy(), parent) { + Ok(policy) => policy.map(PolicyAccuracy::accuracy), + Err(cause) => return Ok::<_, Infallible>(Err(cause)), + } + } + }; + Ok(Ok(interval_in(info.gen_time(), accuracy, utc, &execution))) + }); + match generation { + Ok(Ok(Ok(generation))) => { + first = first.min(generation.earliest); + last = last.max(generation.latest); + } + Ok(Ok(Err(IntervalError::Resource(cause)))) => { + return Ok(Err(ValidationError::Adapter(cause.into()))); + } + Ok(Ok(Err(IntervalError::Uncertain(_)))) => {} + Ok(Err(cause)) => return Ok(Err(cause)), + Err(cause) => return Ok(Err(ValidationError::TokenInfo(Box::new(cause)))), + } + } + Ok::<_, Infallible>(Ok(Interval::between_instants(first, last))) + }, + ) + .map_err(|error| ValidationError::Tokens(Box::new(error)))??; + Ok(Some(span)) +} + +/// Parse caller DER under the operation's certificate parser. +fn read_certificates<'s>( + parser: &'s Parser, + sources: &'s [&'s [u8]], +) -> Result>, Error> { + let mut parsed = parser.memory().vector(); + parsed.try_reserve_exact(sources.len())?; + for bytes in sources { + parsed + .try_push(Certificate::read(parser, bytes, 0).map_err(X509ChainError::Processing)?)?; + } + Ok(parsed.into_owned()) +} diff --git a/crates/xml-sec-xades/src/lib.rs b/crates/xml-sec-xades/src/lib.rs index 9fb8d243..54b043ba 100644 --- a/crates/xml-sec-xades/src/lib.rs +++ b/crates/xml-sec-xades/src/lib.rs @@ -5,27 +5,51 @@ //! catalogue, scalar kernels, hash-use and selected-key receipts that the //! `XMLDSig` verification produced. No second XML representation is built and //! no signature is verified again. [`validate_basic`] runs the B-B checks of -//! ETSI EN 319 132-1 for one selected signature. +//! ETSI EN 319 132-1 for one selected signature, and [`validate`] any level up +//! to B-LTA over the document's own timestamps and validation material. //! -//! Certificate paths are the paths xml-sec already validated: the adapter -//! selects the exact certificates recorded in each signature's X.509 trust -//! evidence and re-checks them through the shared path processor with the -//! operation's provider and certificate policy. +//! Signer paths are the paths xml-sec already validated: the adapter selects +//! the exact certificates recorded in each signature's X.509 trust evidence and +//! re-checks them through the shared path processor with the operation's +//! provider and certificate policy. Timestamp and revocation-authority paths +//! end only at the caller's [`Inputs::anchors`]. +//! +//! A level states what the document structurally carries. Its reports keep +//! every status, including a revoked or stale one, so usability, chronology and +//! trust stay the caller's reading of those facts. Nothing is fetched and no +//! clock is read: statuses are evaluated at the operation's verification time. + +#![cfg_attr(not(feature = "std"), no_std)] + +extern crate alloc; use structured_asn1::memory::{MemoryError, Work}; use xml_sec::document::{DocumentIdentity, NodeIdentity}; use xml_sec::xmldsig::extension::{ScalarError, TreeError}; use xml_sec::xmldsig::{DsigError, VerifiedSession, X509ChainError}; +mod accuracy; mod basic; mod binary; +mod level; mod path; mod signature; +mod status; mod xml; -pub use basic::{CounterError, Outcome, PathFailure, Report, ValidationError, validate_basic}; +pub use accuracy::AuthorityAccuracy; +pub use basic::{ + CounterError, Outcome, PathFailure, Report, TimestampCheckError, ValidationError, + validate_basic, +}; pub use binary::DigestIdentity; +pub use level::{ + ConfiguredResponder, Inputs, Level, NoCredential, RenewalFailure, TimestampFailure, validate, +}; pub use path::CounterPathError; +pub use status::{StatusError, StatusFailure}; +pub use structured_xades::timestamp::TokenProfile; +pub use structured_xades::unsigned::Requirements; /// Original document identity and generation, as seen by the shared core. pub type Snapshot = structured_xades::xml::Snapshot; diff --git a/crates/xml-sec-xades/src/path.rs b/crates/xml-sec-xades/src/path.rs index 7ec8a62d..de0c1364 100644 --- a/crates/xml-sec-xades/src/path.rs +++ b/crates/xml-sec-xades/src/path.rs @@ -2,10 +2,15 @@ use crate::Error; use structured_asn1::Parser; -use structured_asn1::memory::{HashWork, MemoryError, OwnedVec, Work}; +use structured_asn1::memory::{HashWork, Memory, MemoryError, OwnedVec, Work}; use structured_ltv::pki::{CheckedPath, PathOutcome}; -use structured_pkix::Certificate; -use structured_pkix::path::{Anchor, BuildError, Interval, Policy, Truncation, ValidationContext}; +use structured_pkix::path::{ + Anchor, Bounds, BuildError, Context as PathContext, Interval, Policy, Truncation, + ValidationContext, Verified, Verify as PathVerify, WorkingKey, +}; +use structured_pkix::signature::SignatureValue; +use structured_pkix::temporal::Instant; +use structured_pkix::{AlgorithmIdentifier, Certificate}; use xml_sec::document::NodeIdentity; use xml_sec::xmldsig::extension::{self, NodeView}; use xml_sec::xmldsig::{KeyTrustEvidence, VerifiedSession, X509ChainError, X509TrustEvidence}; @@ -116,6 +121,33 @@ pub(crate) fn key_info_certificates( Ok(decoded.into_owned()) } +/// The instant verification validated `signature`'s path at, if it did. +pub(crate) fn verification_time( + signers: &[(NodeIdentity, &X509TrustEvidence)], + signature: NodeIdentity, +) -> Option { + signers + .iter() + .find(|(identity, _)| *identity == signature) + .map(|(_, evidence)| evidence.verification_time()) +} + +/// The decoded `KeyInfo` certificates followed by each of the caller's lists. +pub(crate) fn candidates<'c, Q: Work>( + decoded: &'c [OwnedVec], + [first, second]: [&[&'c [u8]]; 2], + work: &Q, +) -> Result, Error> { + let mut candidates = work.vector(); + candidates.try_reserve_exact(decoded.len() + first.len() + second.len())?; + for bytes in decoded { + candidates.try_push(&bytes[..])?; + } + candidates.try_extend_from_slice(first)?; + candidates.try_extend_from_slice(second)?; + Ok(candidates) +} + fn children( session: &VerifiedSession<'_, '_, '_, W>, parent: NodeIdentity, @@ -270,12 +302,16 @@ impl<'d> Paths<'d> { pub(crate) fn check<'d, W: Work, Q: Work>( session: &VerifiedSession<'_, '_, '_, W>, selection: &'d Selection<'d>, + (root, span): (NodeIdentity, Option), work: &Q, ) -> Result, Error> { let mut entries = work.vector(); for (signature, evidence, path) in &selection.signers { + let interval = span + .filter(|_| *signature == root) + .unwrap_or_else(|| Interval::at_instant(evidence.verification_time())); let outcome = match path { - Ok(path) => checked(session, &selection.certificates, evidence, path, work)?, + Ok(path) => checked(session, &selection.certificates, interval, path, work)?, Err(failure) => Err(*failure), }; entries.try_push((*signature, outcome))?; @@ -288,7 +324,7 @@ pub(crate) fn check<'d, W: Work, Q: Work>( fn checked<'d, W: Work, Q: Work>( session: &VerifiedSession<'_, '_, '_, W>, certificates: &'d [Certificate<'d>], - evidence: &X509TrustEvidence, + interval: Interval, path: &[usize], work: &Q, ) -> Result, PathFailure>, Error> { @@ -302,18 +338,29 @@ fn checked<'d, W: Work, Q: Work>( for position in members { chain.try_push(&certificates[*position])?; } - let anchor = &certificates[*anchor]; - let verifier = session.certificate_path_verifier(&chain, anchor); + check_chain(session, &chain, &certificates[*anchor], interval, work) +} + +/// One leaf-first chain through the shared processor over `interval`, with the +/// operation's provider, certificate policy and path bounds. +pub(crate) fn check_chain<'d, W: Work, Q: Work>( + session: &VerifiedSession<'_, '_, '_, W>, + chain: &[&'d Certificate<'d>], + anchor: &'d Certificate<'d>, + interval: Interval, + work: &Q, +) -> Result, PathFailure>, Error> { + let verifier = session.certificate_path_verifier(chain, anchor); let context = ValidationContext { execution: work, - interval: Interval::at_instant(evidence.verification_time()), + interval, policy: Policy::default(), bounds: session.certificate_path_bounds(), verifier: &verifier, watch: &(), recognizer: &(), }; - match structured_ltv::pki::check_path(&chain, Anchor::from_certificate(anchor), &context) { + match structured_ltv::pki::check_path(chain, Anchor::from_certificate(anchor), &context) { Ok(PathOutcome::Accepted(path)) => Ok(Ok(path)), Ok(PathOutcome::Rejected(_)) => Ok(Err(PathFailure::Rejected)), Ok(PathOutcome::Incomplete(reason)) => Ok(Err(PathFailure::Incomplete(reason))), @@ -322,3 +369,79 @@ fn checked<'d, W: Work, Q: Work>( Err(BuildError::Recognition(never)) => match never {}, } } + +/// Discovery answers which issuers name each other; it proves nothing. +/// [`check_chain`] authenticates every edge of a candidate once, so a forged +/// issuer can only cost its own path's rejection. +struct Unverified; + +impl PathVerify for Unverified { + type Error = core::convert::Infallible; + + fn verify( + &self, + _algorithm: &AlgorithmIdentifier<'_>, + _key: WorkingKey<'_>, + _signed: &[u8], + _signature: SignatureValue<'_>, + _execution: &Memory, + ) -> Result { + Ok(Verified::Yes) + } +} + +/// The caller's trust anchors, the certificates every issuer may come from +/// and the account path work spends. +pub(crate) struct Authorities<'d> { + pub(crate) anchors: &'d [Certificate<'d>], + /// `anchors` in the form path building takes, built once per validation. + pub(crate) anchored: &'d [Anchor<'d>], + pub(crate) pool: &'d [&'d Certificate<'d>], + pub(crate) responders: &'d [crate::level::ConfiguredResponder<'d>], + pub(crate) memory: &'d Memory, +} + +/// The first candidate path from `target` to a caller anchor that the shared +/// processor accepts over `interval`. +pub(crate) fn discover<'d, W: Work>( + session: &VerifiedSession<'_, '_, '_, W>, + authorities: &Authorities<'d>, + target: &'d Certificate<'d>, + interval: Interval, +) -> Result, PathFailure>, Error> { + let memory = authorities.memory; + let bounds = session.certificate_path_bounds(); + let context = PathContext { + execution: memory, + anchors: authorities.anchored, + interval, + bounds: Bounds { + depth: bounds.depth, + work: bounds.work, + policies: bounds.policies, + ..Bounds::default() + }, + policy: Policy::default(), + verifier: &Unverified, + watch: &(), + recognizer: &(), + }; + let found = match structured_pkix::path::build(target, authorities.pool, &context) { + Ok(found) => found, + Err(BuildError::Processing(error)) => return Err(X509ChainError::Processing(error).into()), + Err(BuildError::Verification(never) | BuildError::Recognition(never)) => match never {}, + }; + let mut failure = found + .truncated() + .map_or(PathFailure::NotValidated, PathFailure::Incomplete); + for candidate in found.paths() { + let Some(anchor) = candidate.anchor().certificate() else { + continue; + }; + match check_chain(session, candidate.certificates(), anchor, interval, memory)? { + Ok(path) => return Ok(Ok(path)), + Err(reason) => failure = reason, + } + } + Ok(Err(failure)) +} diff --git a/crates/xml-sec-xades/src/signature.rs b/crates/xml-sec-xades/src/signature.rs index 0ed4edb7..9e8c3698 100644 --- a/crates/xml-sec-xades/src/signature.rs +++ b/crates/xml-sec-xades/src/signature.rs @@ -14,6 +14,7 @@ use structured_xades::reference::{ Boolean, Completeness, Descriptor, LexicalSource, ObjectLocation, Parent, ReferenceXml, Replay, ReplayOutcome, Resolution, VisitError, }; +use structured_xades::timestamp::TimestampXml; use structured_xades::xml::Name; use xml_sec::document::NodeIdentity; use xml_sec::provider; @@ -331,6 +332,25 @@ impl ReferenceXml for Document<'_, '_, '_, '_, W> { } } +impl TimestampXml for Document<'_, '_, '_, '_, W> { + fn canonicalize( + &self, + snapshot: Snapshot, + node: NodeIdentity, + method: NodeIdentity, + receiver: &mut impl Receiver, + execution: &Q, + ) -> Result<(), Error> { + self.check(snapshot)?; + self.session + .canonicalize_element(node, method, execution, &mut |bytes| receiver.write(bytes)) + .map_err(|error| match error { + ReplayError::Processing(error) => error.into(), + ReplayError::Receiver(_) => Error::ReceiverRefused, + }) + } +} + impl CertificateXml for Document<'_, '_, '_, '_, W> { fn key_association( &self, diff --git a/crates/xml-sec-xades/src/status.rs b/crates/xml-sec-xades/src/status.rs new file mode 100644 index 00000000..b5e4d2cf --- /dev/null +++ b/crates/xml-sec-xades/src/status.rs @@ -0,0 +1,963 @@ +//! Original CRL and OCSP evidence bound to every member of every actor path. +//! +//! Each stage borrows only the frozen stages before it: authenticated sources, +//! then one selected status per path member (which may require further +//! authority paths), then the receipts binding those selections to the paths. + +use crate::Error; +use crate::path::{self, Authorities, PathFailure}; +use structured_asn1::memory::{Memory, OwnedVec, Work}; +use structured_ltv::pki::{ + AuthorityNode, CheckedPath, CrlAuthorities, CrlAuthority, CrlBindingError, CrlBindingFailure, + CrlCoverage, CrlCoverageBinding, CrlCoverageError, CrlReading, CrlReadingBinding, + CrlReadingTarget, MemberStatus, OcspBinding, OcspBindingError, OcspBindingFailure, OcspTarget, + PathStatuses, ResponderBinding, ResponderError, ResponderFailure, ResponderPath, + StatusCensusError, +}; +use structured_pkix::Certificate; +use structured_pkix::crl::{ + Authenticated, Authentication, CertificateList, CombinedEntry, CompleteEvidence, CompleteFacts, + Coverage, CoverageAdmission, DeltaBinding, DeltaEvidence, DeltaFacts, EntryLookup, Evaluation, + SourceOrigin, +}; +use structured_pkix::error::CallbackError; +use structured_pkix::ocsp::{ + self, AuthorityBinding, BasicResponse, BoundEvidence, Delegation, Request, ResponderRevocation, + SignatureAuthentication, SignatureError, SignedResponse, check_delegate, +}; +use structured_pkix::path::{Anchor, BuildError, Interval, Policy, ValidationContext, WorkingKey}; +use structured_pkix::temporal::{Instant, LeapTable, Reading}; +use xml_sec::xmldsig::VerifiedSession; +use xml_sec::xmldsig::X509ChainError; +use xml_sec::xmldsig::cms::{CmsProvider, CmsProviderError}; + +/// A status source that could not be processed, with its original cause. +#[derive(Debug, thiserror::Error)] +pub enum StatusError { + /// Shared CRL or OCSP processing failed. + #[error(transparent)] + Pkix(#[from] structured_pkix::Error), + /// A signature could not be checked. + #[error(transparent)] + Verification(#[from] X509ChainError), + /// An OCSP identity hash could not be computed. + #[error(transparent)] + Digest(#[from] CmsProviderError), + /// Adapter or resource failure. + #[error(transparent)] + Adapter(#[from] Error), + /// A CRL could not be associated with its path member. + #[error("CRL binding failed: {0:?}")] + CrlBinding(CrlBindingError), + /// A CRL's contributors could not be associated with their path member. + #[error("CRL coverage binding failed: {0:?}")] + CrlCoverage(CrlCoverageError), + /// An OCSP response could not be associated with its path member. + #[error("OCSP binding failed: {0:?}")] + OcspBinding(OcspBindingError), + /// A delegated responder could not be associated with its full path. + #[error("OCSP responder binding failed: {0:?}")] + Responder(ResponderError), + /// A path's status inputs are not its complete census. + #[error("status census failed: {0:?}")] + Census(StatusCensusError), +} + +/// Why a path member has no usable status input. None of these says that the +/// certificate is revoked: a revoked or stale status is a retained fact. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum StatusFailure { + /// No supplied CRL or OCSP response speaks about this certificate. + NoSource, + /// The authority of an applicable source has no accepted path. + AuthorityPath(PathFailure), + /// A CRL does not belong to the path member it was selected for. + Crl(CrlBindingFailure), + /// An OCSP response does not belong to the path member it was selected for. + Ocsp(OcspBindingFailure), + /// A delegated responder does not belong to the full path it was given. + Responder(ResponderFailure), +} + +/// Who signed a selected list. +#[derive(Clone, Copy)] +enum Signer { + /// The target path's own anchor. + Anchor, + /// The path at this ordinal. + Path(usize), +} + +/// The signers of one contributor to a CRL coverage. +#[derive(Clone, Copy)] +enum CrlAuthoritySource { + Complete(Signer), + Delta(Signer, Signer), +} + +/// A selection that could not be established, or the selection and whether a +/// delegated responder is exempt from its own status. +type Selection<'f, 'x> = Option, bool), PathFailure>>; + +/// One member's selected status, independent of any path receipt. +#[expect( + clippy::large_enum_variant, + reason = "retained by value in one frozen accounted plan rather than boxed per member" +)] +enum Selected<'f, 'x> { + Ocsp { + evidence: BoundEvidence<'x, 'x, 'x, 'x>, + /// The delegated responder's full path, for a response it signed. + responder: Option, + }, + Absent { + coverage: Coverage<'x, 'x>, + /// The range of this coverage's source signers in the shared list. + signers: (usize, usize), + }, + Complete { + facts: CompleteFacts<'f, 'x, 'x>, + signer: Signer, + }, + Delta { + facts: DeltaFacts<'f, 'x, 'x>, + base: Signer, + delta: Signer, + }, + /// The final member of a responder path whose response carries noCheck. + NoCheck { + /// The plan of the response that responder signed. + plan: usize, + }, +} + +struct Plan<'f, 'x> { + path: usize, + member: usize, + selected: Selected<'f, 'x>, +} + +struct Engine<'e, 'x, 'v, 's, 'i, W: Work> { + session: &'e VerifiedSession<'v, 's, 'i, W>, + cms: &'e CmsProvider<'e>, + authorities: &'e Authorities<'x>, + lists: &'e [Authenticated<'x, 'x>], + deltas: &'e [Authenticated<'x, 'x>], + responses: &'e [SignedResponse<'x, 'x>], + utc: &'x LeapTable<'x>, + at: Instant, +} + +/// Every supplied list its issuer's own key authenticates. Lists no available +/// certificate authenticates stay unused: nothing here may rely on them. +fn authenticated_lists<'x, W: Work>( + session: &VerifiedSession<'_, '_, '_, W>, + authorities: &Authorities<'x>, + lists: &[&'x CertificateList<'x>], +) -> Result< + ( + OwnedVec>, + OwnedVec>, + ), + StatusError, +> { + let memory = authorities.memory; + let verifier = session.revocation_verifier(); + let (mut complete, mut delta) = (memory.vector(), memory.vector()); + for list in lists { + for candidate in authorities + .anchors + .iter() + .chain(authorities.pool.iter().copied()) + { + if !list + .tbs() + .issuer() + .matches(candidate.tbs().subject(), memory)? + { + continue; + } + let key = WorkingKey::standing(candidate.tbs().public_key()); + let answer = list + .authenticate(candidate, key, &verifier, memory) + .map_err(|error| match error { + CallbackError::Processing(error) => StatusError::Pkix(error), + CallbackError::Callback(error) => StatusError::Verification(error), + })?; + let Authentication::Authenticated(proof) = answer else { + continue; + }; + let is_delta = list + .tbs() + .extensions() + .get(structured_pkix::oid::DELTA_CRL_INDICATOR, memory)? + .is_some(); + if is_delta { + delta.try_push(proof).map_err(Error::from)?; + } else { + complete.try_push(proof).map_err(Error::from)?; + } + break; + } + } + Ok((complete.into_owned(), delta.into_owned())) +} + +/// Every supplied response with the certificate whose key signed it. +/// RFC 6960 §4.2.2.2 authorization is a separate per-target decision. +fn signed_responses<'x, W: Work>( + session: &VerifiedSession<'_, '_, '_, W>, + cms: &CmsProvider<'_>, + authorities: &Authorities<'x>, + responses: &[&'x BasicResponse<'x>], +) -> Result>, StatusError> { + let memory = authorities.memory; + let verifier = session.revocation_verifier(); + let mut signed = memory.vector(); + for response in responses { + for candidate in response + .certificates() + .iter() + .chain(authorities.pool.iter().copied()) + { + let key = WorkingKey::standing(candidate.tbs().public_key()); + let answer = response + .authenticate_signature(candidate, key, &verifier, cms, memory) + .map_err(|error| match error { + SignatureError::Processing(error) => StatusError::Pkix(error), + SignatureError::Verification(error) => StatusError::Verification(error), + SignatureError::Digest(error) => StatusError::Digest(error), + })?; + if let SignatureAuthentication::Signed(value) = answer { + signed.try_push(value).map_err(Error::from)?; + break; + } + } + } + Ok(signed.into_owned()) +} + +impl<'e, 'x, W: Work> Engine<'e, 'x, '_, '_, '_, W> { + fn evaluation(&self) -> Evaluation<'_, structured_asn1::memory::Memory> { + Evaluation { + now: Reading::from(self.at), + utc: self.utc, + execution: self.authorities.memory, + // Material incorporated in a document is held, not newly fetched + // (RFC 5280 §6.3.3(a)). + // https://www.rfc-editor.org/rfc/rfc5280#section-6.3.3 + origin: SourceOrigin::Cached, + } + } + + /// The ordinal of the accepted path to `target` at the evaluation instant, + /// reusing a path already built for it. + fn authority_path( + &self, + target: &'x Certificate<'x>, + roots: usize, + extra: &mut OwnedVec, structured_asn1::memory::Memory>, + ) -> Result, StatusError> { + for (index, path) in extra.iter().enumerate() { + let member = path.members().last().expect("a checked path has a target"); + if member.certificate().as_bytes() == target.as_bytes() { + return Ok(Ok(roots + index)); + } + } + let interval = Interval::at_instant(self.at); + match path::discover(self.session, self.authorities, target, interval)? { + Ok(path) => { + extra.try_push(path).map_err(Error::from)?; + Ok(Ok(roots + extra.len() - 1)) + } + Err(failure) => Ok(Err(failure)), + } + } + + fn signer( + &self, + anchor: Anchor<'x>, + issuer: &'x Certificate<'x>, + roots: usize, + extra: &mut OwnedVec, structured_asn1::memory::Memory>, + ) -> Result, StatusError> { + if anchor + .certificate() + .is_some_and(|certificate| certificate.as_bytes() == issuer.as_bytes()) + { + return Ok(Ok(Signer::Anchor)); + } + Ok(self.authority_path(issuer, roots, extra)?.map(Signer::Path)) + } + + /// Whether an authenticated complete list, or a delta bound to one, names + /// `target`. + fn listed(&self, target: &'x Certificate<'x>) -> Result { + let memory = self.authorities.memory; + let time = self.evaluation(); + for list in self.lists { + let CompleteEvidence::Facts(facts) = list.evaluate(target, &time)? else { + continue; + }; + if !matches!(facts.entry(), EntryLookup::Absent) { + return Ok(true); + } + for delta in self.deltas { + let DeltaBinding::Bound(pair) = list.bind_delta(delta, memory)? else { + continue; + }; + if let DeltaEvidence::Facts(facts) = pair.evaluate(target, &time)? + && !matches!( + facts.entry(), + CombinedEntry::Absent | CombinedEntry::Removed { .. } + ) + { + return Ok(true); + } + } + } + Ok(false) + } + + /// An OCSP response for `target` its issuer, a delegate of that issuer or a + /// responder the caller configured for it signed. Configured trust is never + /// inferred from a document. + fn ocsp( + &self, + target: &'x Certificate<'x>, + issuer: &'x Certificate<'x>, + issuing: WorkingKey<'x>, + roots: usize, + extra: &mut OwnedVec, structured_asn1::memory::Memory>, + ) -> Result, StatusError> { + let memory = self.authorities.memory; + for signed in self.responses { + let delegated = signed.signer().as_bytes() != issuer.as_bytes(); + let configured = delegated + && self.authorities.responders.iter().any(|entry| { + entry.responder == signed.signer().as_bytes() + && entry.issuer == issuer.as_bytes() + }); + let (binding, no_check) = if configured { + // RFC 6960 §4.2.2.2: local configuration, the branch that needs + // neither a delegation certificate nor the responder's own path. + ( + AuthorityBinding::Bound(signed.trust_for_issuer(issuer)), + false, + ) + } else if delegated { + let chain = [signed.signer()]; + let verifier = self.session.certificate_path_verifier(&chain, issuer); + let context = ValidationContext { + execution: memory, + interval: Interval::at_instant(self.at), + policy: Policy::default(), + bounds: self.session.certificate_path_bounds(), + verifier: &verifier, + watch: &(), + recognizer: &(), + }; + let delegation = match check_delegate(signed.signer(), issuer, issuing, &context) { + Ok(delegation) => delegation, + Err(BuildError::Processing(error)) => return Err(error.into()), + Err(BuildError::Verification(error)) => return Err(error.into()), + Err(BuildError::Recognition(never)) => match never {}, + }; + let Delegation::Accepted(facts) = delegation else { + continue; + }; + let no_check = facts.revocation() == ResponderRevocation::NoCheck; + (signed.bind_delegate(facts, memory)?, no_check) + } else { + (signed.bind_issuer(issuer, issuing, memory)?, false) + }; + let AuthorityBinding::Bound(scoped) = binding else { + continue; + }; + let request = Request { + target, + nonce: None, + intended_signer: None, + }; + let time = ocsp::Evaluation { + now: Reading::from(self.at), + utc: self.utc, + execution: memory, + }; + let reading = scoped + .evaluate_with_target(&request, &time, self.cms) + .map_err(|error| match error { + CallbackError::Processing(error) => StatusError::Pkix(error), + CallbackError::Callback(error) => StatusError::Digest(error), + })?; + let Some(evidence) = reading.evidence() else { + continue; + }; + let responder = if delegated && !configured { + match self.authority_path(signed.signer(), roots, extra)? { + Ok(path) => Some(path), + Err(failure) => return Ok(Some(Err(failure))), + } + } else { + None + }; + return Ok(Some(Ok(( + Selected::Ocsp { + evidence, + responder, + }, + no_check, + )))); + } + Ok(None) + } + + /// The CRL evidence for `target`, combining every applicable complete list + /// with its newest bound delta (RFC 5280 §6.3.3). + fn crl( + &self, + anchor: Anchor<'x>, + target: &'x Certificate<'x>, + roots: usize, + extra: &mut OwnedVec, structured_asn1::memory::Memory>, + signers: &mut OwnedVec, + ) -> Result, PathFailure>>, StatusError> { + let memory = self.authorities.memory; + let time = self.evaluation(); + let first = signers.len(); + let mut coverage: Option> = None; + let mut negative = None; + for list in self.lists { + let CompleteEvidence::Facts(facts) = list.evaluate(target, &time)? else { + continue; + }; + let signer = match self.signer(anchor, list.issuer(), roots, extra)? { + Ok(signer) => signer, + Err(failure) => return Ok(Some(Err(failure))), + }; + let mut newest = None; + for delta in self.deltas { + let DeltaBinding::Bound(pair) = list.bind_delta(delta, memory)? else { + continue; + }; + let newer = match newest { + None => true, + Some(current) => pair.compare_delta_number(current, memory)?.is_gt(), + }; + if newer { + newest = Some(pair); + } + } + let (absence, source) = if let Some(pair) = newest { + let DeltaEvidence::Facts(facts) = pair.evaluate(target, &time)? else { + continue; + }; + let absence = facts.absence(); + if absence.is_none() { + let listed = !matches!( + facts.entry(), + CombinedEntry::Absent | CombinedEntry::Removed { .. } + ); + let selected = Selected::Delta { + base: signer, + delta: signer, + facts, + }; + if listed { + return Ok(Some(Ok(selected))); + } + negative = Some(selected); + } + (absence, CrlAuthoritySource::Delta(signer, signer)) + } else { + let absence = facts.absence(); + if absence.is_none() { + // A listed entry decides whatever another list omits + // (RFC 5280 §6.3.3(i)); a stale list decides nothing + // while a current one covers the target. + // https://www.rfc-editor.org/rfc/rfc5280#section-6.3.3 + let selected = Selected::Complete { facts, signer }; + if !matches!(facts.entry(), EntryLookup::Absent) { + return Ok(Some(Ok(selected))); + } + negative = Some(selected); + } + (absence, CrlAuthoritySource::Complete(signer)) + }; + let Some(absence) = absence else { + continue; + }; + let added = if let Some(value) = &mut coverage { + value.add(absence, memory)? == CoverageAdmission::Added + } else { + coverage = Some(Coverage::new(absence, memory)?); + true + }; + if added { + signers.try_push(source).map_err(Error::from)?; + } + } + Ok(match coverage { + Some(coverage) => Some(Ok(Selected::Absent { + signers: (first, signers.len()), + coverage, + })), + None => negative.map(Ok), + }) + } +} + +/// The path at `cursor` of the roots followed by the reached authorities. +fn path_at<'p, 'x>( + roots: &'p [&'x CheckedPath<'x>], + extra: &'p [CheckedPath<'x>], + cursor: usize, +) -> &'p CheckedPath<'x> { + match roots.get(cursor) { + Some(path) => path, + None => &extra[cursor - roots.len()], + } +} + +/// Select and bind status for each of `roots`' members and every authority they +/// reach, then hand `then` the census of each root and all authority nodes. +#[expect( + clippy::too_many_arguments, + reason = "each argument is one frozen pool of this operation" +)] +pub(crate) fn with_statuses<'x, W: Work, R>( + session: &VerifiedSession<'_, '_, '_, W>, + cms: &CmsProvider<'_>, + authorities: &'x Authorities<'x>, + lists: &[&'x CertificateList<'x>], + responses: &[&'x BasicResponse<'x>], + roots: &'x [&'x CheckedPath<'x>], + utc: &'x LeapTable<'x>, + at: Instant, + then: impl for<'v> FnOnce(&'v [&'v PathStatuses<'v, 'x, 'x>], &'v [AuthorityNode<'v, 'x, 'x>]) -> R, +) -> Result, StatusError> { + let memory = authorities.memory; + let (complete, deltas) = authenticated_lists(session, authorities, lists)?; + let signed = signed_responses(session, cms, authorities, responses)?; + let engine = Engine { + session, + cms, + authorities, + lists: &complete, + deltas: &deltas, + responses: &signed, + utc, + at, + }; + let mut extra = memory.vector(); + let mut signers = memory.vector(); + let mut plans: OwnedVec, _> = memory.vector(); + // Responder paths and the plan of the response each one signed. + let mut exempt: OwnedVec<(usize, usize), _> = memory.vector(); + let mut cursor = 0; + // Selection may append to `extra`, so each member is read through the index. + while cursor < roots.len() + extra.len() { + let (anchor, count) = { + let path = path_at(roots, &extra, cursor); + (path.anchor(), path.members().len()) + }; + for index in 0..count { + let target = path_at(roots, &extra, cursor).members()[index].certificate(); + if index + 1 == count + && let Some((_, plan)) = exempt.iter().find(|(path, _)| *path == cursor) + { + plans + .try_push(Plan { + path: cursor, + member: index, + selected: Selected::NoCheck { plan: *plan }, + }) + .map_err(Error::from)?; + continue; + } + let (issuer, issuing) = if let Some(index) = index.checked_sub(1) { + let member = &path_at(roots, &extra, cursor).members()[index]; + (Some(member.certificate()), member.key()) + } else { + (anchor.certificate(), WorkingKey::standing(anchor.key())) + }; + // A listed entry decides whatever another source omits (RFC 5280 + // §6.3.3(i)), so a good OCSP answer cannot hide it from the report. + let ocsp = match issuer { + Some(issuer) if !engine.listed(target)? => { + engine.ocsp(target, issuer, issuing, roots.len(), &mut extra)? + } + _ => None, + }; + let selected = match ocsp { + Some(Ok((selected, no_check))) => { + if no_check + && let Selected::Ocsp { + responder: Some(path), + .. + } = selected + { + exempt.try_push((path, plans.len())).map_err(Error::from)?; + } + selected + } + Some(Err(failure)) => return Ok(Err(StatusFailure::AuthorityPath(failure))), + None => match engine.crl(anchor, target, roots.len(), &mut extra, &mut signers)? { + Some(Ok(selected)) => selected, + Some(Err(failure)) => return Ok(Err(StatusFailure::AuthorityPath(failure))), + None => return Ok(Err(StatusFailure::NoSource)), + }, + }; + plans + .try_push(Plan { + path: cursor, + member: index, + selected, + }) + .map_err(Error::from)?; + } + cursor += 1; + } + let mut every: OwnedVec<&CheckedPath<'x>, _> = memory.vector(); + every + .try_reserve_exact(roots.len() + extra.len()) + .map_err(Error::from)?; + every.try_extend_from_slice(roots).map_err(Error::from)?; + for path in &extra { + every.try_push(path).map_err(Error::from)?; + } + let frozen = Frozen { + memory, + every: &every, + roots: roots.len(), + plans: &plans, + utc, + at, + }; + bind_authorities(&frozen, &signers, then) +} + +/// The selections and the paths they may name, frozen for every receipt. +struct Frozen<'b, 'x> { + memory: &'b Memory, + every: &'b [&'b CheckedPath<'x>], + roots: usize, + plans: &'b [Plan<'b, 'x>], + utc: &'b LeapTable<'x>, + at: Instant, +} + +/// Each CRL source's checked signer, ahead of the receipts that borrow them. +fn bind_authorities<'b, 'x, R>( + frozen: &Frozen<'b, 'x>, + signers: &[CrlAuthoritySource], + then: impl for<'v> FnOnce(&'v [&'v PathStatuses<'v, 'x, 'x>], &'v [AuthorityNode<'v, 'x, 'x>]) -> R, +) -> Result, StatusError> { + let Frozen { + memory, + every, + plans, + .. + } = *frozen; + let resolve = |signer: Signer| -> CrlAuthority<'_, 'x> { + match signer { + Signer::Anchor => CrlAuthority::Anchor, + Signer::Path(path) => CrlAuthority::Path(every[path]), + } + }; + let mut authorities = memory.vector(); + let mut delta_authorities = memory.vector(); + for plan in plans { + match &plan.selected { + Selected::Absent { + signers: (first, last), + .. + } => { + for source in &signers[*first..*last] { + authorities + .try_push(match *source { + CrlAuthoritySource::Complete(signer) => { + CrlAuthorities::Complete(resolve(signer)) + } + CrlAuthoritySource::Delta(base, delta) => CrlAuthorities::Delta { + base: resolve(base), + delta: resolve(delta), + }, + }) + .map_err(Error::from)?; + } + } + Selected::Complete { signer, .. } => { + delta_authorities + .try_push(CrlAuthorities::Complete(resolve(*signer))) + .map_err(Error::from)?; + } + Selected::Delta { base, delta, .. } => { + delta_authorities + .try_push(CrlAuthorities::Delta { + base: resolve(*base), + delta: resolve(*delta), + }) + .map_err(Error::from)?; + } + Selected::Ocsp { .. } | Selected::NoCheck { .. } => {} + } + } + bind_sources(frozen, &authorities, &delta_authorities, then) +} + +/// A receipt for every selected source, or the mismatch that refuses one. +fn bind_sources<'b, 'x, R>( + frozen: &Frozen<'b, 'x>, + authorities: &[CrlAuthorities<'_, 'x>], + delta_authorities: &[CrlAuthorities<'_, 'x>], + then: impl for<'v> FnOnce(&'v [&'v PathStatuses<'v, 'x, 'x>], &'v [AuthorityNode<'v, 'x, 'x>]) -> R, +) -> Result, StatusError> { + let Frozen { + memory, + every, + plans, + utc, + .. + } = *frozen; + let (mut coverages, mut readings, mut targets) = + (memory.vector(), memory.vector(), memory.vector()); + let (mut authority, mut negative) = (0, 0); + for plan in plans { + let path = every[plan.path]; + match &plan.selected { + Selected::Absent { + coverage, + signers: (first, last), + } => { + let count = last - first; + let used = &authorities[authority..authority + count]; + authority += count; + match path + .bind_crl_coverage(plan.member, coverage, used, utc, memory) + .map_err(StatusError::CrlCoverage)? + { + CrlCoverageBinding::Bound(value) => { + coverages.try_push(value).map_err(Error::from)?; + } + CrlCoverageBinding::Rejected { cause, .. } => { + return Ok(Err(StatusFailure::Crl(cause))); + } + } + } + Selected::Complete { facts, .. } => { + let used = delta_authorities[negative]; + negative += 1; + match path + .bind_crl_reading(plan.member, CrlReading::Complete(facts), used, utc, memory) + .map_err(StatusError::CrlBinding)? + { + CrlReadingBinding::Bound(value) => { + readings.try_push(value).map_err(Error::from)?; + } + CrlReadingBinding::Rejected(cause) => { + return Ok(Err(StatusFailure::Crl(cause))); + } + } + } + Selected::Delta { facts, .. } => { + let used = delta_authorities[negative]; + negative += 1; + match path + .bind_crl_reading(plan.member, CrlReading::Delta(facts), used, utc, memory) + .map_err(StatusError::CrlBinding)? + { + CrlReadingBinding::Bound(value) => { + readings.try_push(value).map_err(Error::from)?; + } + CrlReadingBinding::Rejected(cause) => { + return Ok(Err(StatusFailure::Crl(cause))); + } + } + } + Selected::Ocsp { evidence, .. } => { + match path + .bind_ocsp(plan.member, evidence, memory) + .map_err(StatusError::OcspBinding)? + { + OcspBinding::Bound(value) => targets.try_push(value).map_err(Error::from)?, + OcspBinding::Rejected(cause) => { + return Ok(Err(StatusFailure::Ocsp(cause))); + } + } + } + Selected::NoCheck { .. } => {} + } + } + bind_responders(frozen, &coverages, &readings, &targets, then) +} + +/// A full-path receipt for every delegated responder. +fn bind_responders<'x, R>( + frozen: &Frozen<'_, 'x>, + coverages: &[CrlCoverage<'_, 'x, 'x>], + readings: &[CrlReadingTarget<'_, 'x, 'x>], + targets: &[OcspTarget<'_, 'x, 'x>], + then: impl for<'v> FnOnce(&'v [&'v PathStatuses<'v, 'x, 'x>], &'v [AuthorityNode<'v, 'x, 'x>]) -> R, +) -> Result, StatusError> { + let Frozen { + memory, + every, + plans, + utc, + .. + } = *frozen; + let mut responders = memory.vector(); + let mut target = 0; + let mut response_targets: OwnedVec, _> = memory.vector(); + for plan in plans { + let mut ordinal = None; + if let Selected::Ocsp { responder, .. } = &plan.selected { + let bound: &OcspTarget<'_, 'x, 'x> = &targets[target]; + target += 1; + if let Some(responder) = responder { + match bound + .bind_responder_path(every[*responder], utc, memory) + .map_err(StatusError::Responder)? + { + ResponderBinding::Bound(value) => { + ordinal = Some(responders.len()); + responders.try_push(value).map_err(Error::from)?; + } + ResponderBinding::Rejected(cause) => { + return Ok(Err(StatusFailure::Responder(cause))); + } + } + } + } + response_targets.try_push(ordinal).map_err(Error::from)?; + } + let sources = Sources { + coverages, + readings, + targets, + responders: &responders, + response_targets: &response_targets, + }; + conclude(frozen, &sources, then) +} + +/// Every receipt of one operation, in plan order per kind. +struct Sources<'b, 'v, 'x> { + coverages: &'b [CrlCoverage<'v, 'x, 'x>], + readings: &'b [CrlReadingTarget<'v, 'x, 'x>], + targets: &'b [OcspTarget<'v, 'x, 'x>], + responders: &'b [ResponderPath<'b, 'v, 'x, 'x>], + response_targets: &'b [Option], +} + +/// One status input per plan, in plan order. +fn member_statuses<'b, 'x>( + plans: &[Plan<'_, 'x>], + sources: &Sources<'b, 'b, 'x>, + memory: &Memory, +) -> Result>, Error> { + let (mut coverage, mut reading, mut target) = (0, 0, 0); + let mut entries = memory.vector(); + for plan in plans { + entries.try_push(match &plan.selected { + Selected::Absent { .. } => { + coverage += 1; + MemberStatus::Crl(&sources.coverages[coverage - 1]) + } + Selected::Complete { .. } | Selected::Delta { .. } => { + reading += 1; + MemberStatus::CrlReading(&sources.readings[reading - 1]) + } + Selected::Ocsp { .. } => { + target += 1; + MemberStatus::Ocsp(&sources.targets[target - 1]) + } + Selected::NoCheck { plan } => { + let ordinal = + sources.response_targets[*plan].expect("a noCheck plan names its response"); + MemberStatus::ResponderNoCheck(&sources.responders[ordinal]) + } + })?; + } + Ok(entries.into_owned()) +} + +/// Each path's census and its authority node. +fn conclude<'x, R>( + frozen: &Frozen<'_, 'x>, + sources: &Sources<'_, '_, 'x>, + then: impl for<'v> FnOnce(&'v [&'v PathStatuses<'v, 'x, 'x>], &'v [AuthorityNode<'v, 'x, 'x>]) -> R, +) -> Result, StatusError> { + let Frozen { + memory, + every, + roots, + plans, + at, + .. + } = *frozen; + let responders = sources.responders; + let entries = member_statuses(plans, sources, memory)?; + let reading_at = Reading::from(at); + let mut statuses = memory.vector(); + statuses + .try_reserve_exact(every.len()) + .map_err(Error::from)?; + let mut first = 0; + for (ordinal, path) in every.iter().enumerate() { + let count = plans[first..] + .iter() + .take_while(|plan| plan.path == ordinal) + .count(); + statuses + .try_push( + path.status_census(reading_at, &entries[first..first + count], memory) + .map_err(StatusError::Census)?, + ) + .map_err(Error::from)?; + first += count; + } + let mut references = memory.vector(); + for plan in plans { + if let Selected::Ocsp { + responder: Some(_), .. + } = plan.selected + { + references.try_push(plan.path).map_err(Error::from)?; + } + } + let mut delegated = memory.vector(); + delegated + .try_reserve_exact(responders.len()) + .map_err(Error::from)?; + for responder in responders { + delegated.try_push(responder).map_err(Error::from)?; + } + let mut nodes = memory.vector(); + nodes + .try_reserve_exact(statuses.len()) + .map_err(Error::from)?; + let mut cursor = 0; + for (ordinal, statuses) in statuses.iter().enumerate() { + let count = references[cursor..] + .iter() + .take_while(|path| **path == ordinal) + .count(); + nodes + .try_push(AuthorityNode { + statuses, + responders: &delegated[cursor..cursor + count], + }) + .map_err(Error::from)?; + cursor += count; + } + let mut root_statuses = memory.vector(); + root_statuses + .try_reserve_exact(roots) + .map_err(Error::from)?; + for status in statuses.iter().take(roots) { + root_statuses.try_push(status).map_err(Error::from)?; + } + Ok(Ok(then(&root_statuses, &nodes))) +} diff --git a/crates/xml-sec-xades/tests/element.rs b/crates/xml-sec-xades/tests/element.rs new file mode 100644 index 00000000..329269cd --- /dev/null +++ b/crates/xml-sec-xades/tests/element.rs @@ -0,0 +1,172 @@ +//! Element canonicalization and owned base64 values of a verified session. + +use std::collections::BTreeSet; +use std::sync::Arc; + +use structured_asn1::memory::{Memory, MemoryAccount}; +use xml_sec::XmlDocument; +use xml_sec::document::NodeIdentity; +use xml_sec::policy::{Instant, VerificationPolicy}; +use xml_sec::xmldsig::extension::{self, NodeView, TreeError}; +use xml_sec::xmldsig::{ + DefaultKeyResolver, DsigError, KeyResolverConfig, ReplayError, VerificationRequest, + VerifiedSession, VerifyContext, with_verified_request, +}; + +const ROOT: &[u8] = include_bytes!("fixtures/levels/root.der"); +const SIGNED: &str = include_str!("fixtures/levels/b-t.xml"); + +fn verified( + configure: impl FnOnce(&mut VerificationPolicy), + check: impl FnOnce(&VerifiedSession<'_, '_, '_, Memory>) -> R, +) -> R { + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: vec![ROOT.to_vec()], + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Instant::new(500_000 * 3600, 0); + configure(&mut policy); + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(SIGNED).expect("fixture parses"); + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 24, 1 << 30))); + with_verified_request( + &document, + &context, + &VerificationRequest::default(), + &account, + |session| Ok(check(&session)), + ) + .expect("fixture verifies as XMLDSig") +} + +/// The first element in document order called `local`. +fn element(session: &VerifiedSession<'_, '_, '_, Memory>, local: &str) -> NodeIdentity { + fn find( + session: &VerifiedSession<'_, '_, '_, Memory>, + node: NodeIdentity, + local: &str, + ) -> Option { + let (view, work) = (session.view(), session.execution()); + let matches = extension::inspect_node( + view, + node, + work, + |value| matches!(value, NodeView::Element { local_name, .. } if local_name == local), + ) + .expect("readable node"); + if matches { + return Some(node); + } + let mut child = extension::first_child(view, node, work).expect("readable node"); + while let Some(current) = child { + if let Some(found) = find(session, current, local) { + return Some(found); + } + child = extension::next_sibling(view, node, current, work).expect("readable node"); + } + None + } + find(session, session.view().root_element(), local).expect("the fixture has the element") +} + +#[test] +fn an_element_streams_its_exclusive_canonical_form() { + // libxml2 produced the imprint the fixture's token signs; here the shape + // shows the namespace the ancestors declared is rendered where it is used. + verified( + |_| {}, + |session| { + let (value, method) = ( + element(session, "SignatureValue"), + element(session, "CanonicalizationMethod"), + ); + let mut output = Vec::new(); + session + .canonicalize_element(value, method, session.execution(), &mut |bytes: &[u8]| { + output.extend_from_slice(bytes); + Ok::<_, ()>(()) + }) + .expect("the method is permitted"); + let text = String::from_utf8(output).expect("canonical XML is UTF-8"); + assert!(text.starts_with(""), "{text}"); + }, + ); +} + +#[test] +fn a_method_outside_the_transform_policy_is_refused() { + // The timestamp method is an attacker-written node: it obeys the same + // permission as a Reference transform, before any output. + verified( + |policy| { + policy.transforms.allowed_algorithms = + Some(BTreeSet::from(["urn:test:other".to_owned()])); + }, + |session| { + let (value, method) = ( + element(session, "SignatureValue"), + element(session, "CanonicalizationMethod"), + ); + let result = session.canonicalize_element( + value, + method, + session.execution(), + &mut |_: &[u8]| -> Result<(), ()> { panic!("no output may reach the receiver") }, + ); + assert!( + matches!( + result, + Err(ReplayError::Processing( + DsigError::AccountedPolicyAlgorithm { .. } + )) + ), + "{result:?}" + ); + }, + ); +} + +#[test] +fn a_receiver_refusal_keeps_its_own_cause() { + verified( + |_| {}, + |session| { + let (value, method) = ( + element(session, "SignatureValue"), + element(session, "CanonicalizationMethod"), + ); + let result = session.canonicalize_element( + value, + method, + session.execution(), + &mut |_: &[u8]| Err("refused"), + ); + assert!(matches!(result, Err(ReplayError::Receiver("refused")))); + }, + ); +} + +#[test] +fn owned_base64_is_the_scoped_value_and_stays_charged() { + verified( + |_| {}, + |session| { + let value = element(session, "SignatureValue"); + let view = session.view(); + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 16, 1 << 20))); + let owned = extension::base64_owned(view, value, &account).expect("base64 value"); + assert!(account.used() >= owned.len()); + let scoped = extension::with_base64(view, value, &account, <[u8]>::to_vec) + .expect("base64 value"); + assert_eq!(&owned[..], &scoped[..]); + let empty = Memory::new(Arc::new(MemoryAccount::new(0, 1 << 20))); + assert!(matches!( + extension::base64_owned(view, value, &empty), + Err(TreeError::Resource(_)) + )); + }, + ); +} diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml new file mode 100644 index 00000000..682491a0 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml new file mode 100644 index 00000000..d271e183 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIB2DCBwQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1owJzAlAhQS0/5qlL2vnLqDMiJpt2dFeI64KhcNMjYxMDAxMDAwMDAwWqA+MDwwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYDVR0bAQH/BAMCAQEwCgYDVR0UBAMCAQIwDQYJKoZIhvcNAQELBQADggEBAGT75au1MO01G3qFbe3GagoPmWZUMhwskgtroSPAawecMVMpsGBVVPiVTrl3pw59/JhfF+t1c4LFJo5JcVD+twiZR7QTnIGIWrELeeqLZzP84EDVKmqaWGrBU178xqHQWfArBp/a5lK8K4dWX3ksZ2H3Qgn5qruvszo0eXZt3UI/cNLjSkYXED6xoEC7wsfk8huIB1YgzzyljexHBV/DsGaaF/5NPORCRGhASQU1kOUk41yPIJLYEz/86+NI0TD1eA01riLj27OVuZAnatR8kptk3/uSGSK/FgKtzRWo0ohL35y9ehgGLuGvRsOz+Yv3awJPiqoZQe/g/BXpQe8fDUc=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml new file mode 100644 index 00000000..ed992195 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1owJzAlAhQS0/5qlL2vnLqDMiJpt2dFeI64KhcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBALF0oPxWZkQ+GsWAzMABJcst4OQJC+uRDKZ81IBrsBfVcvynlcUpaJgVCRYSveUVquieuJuLDI9zC+2TYPOFjf1odWbK8aVVHcwx2gG8vZmhfldpun5xXWo+fJgZE4B6bZXsXE4AKt3CiN+K2/inNftRes6I5zbU+EKyH7uQCBEAXr2ETL48iS4TsBec9TSYTFLh49N4006wdmoxF54m4QDCtbKiIouyLDOXI+33kuffb9gTZA7wAR/NsVkAdp0j2owzpNz9yK/lNyPcHk/yih4xF60D/rrg8jWEN8OTqZX1aFBPW9JNQxVHaxib+/h0cEwHrXouJxLfJ1C4Jdu96Pw=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml new file mode 100644 index 00000000..2569703c --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml @@ -0,0 +1,150 @@ + +Countersigned payload + + + + + + + + + + + wFx65FgWP320/tdoEG8oRYTvlMF8BGcCwEMba4AOejI= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + zekRlXUqBDe4sM+NrPhpz1LmyoVtT6rJ6zOe9fj3U0m+RMWl3+JRfmXaUxzw8VTi +LtkK7QGjqCT8NP6xJNReMFX8BPdFrFmg7WOUl47drmNTCuOaBAU+4CC3BoEYyfVe +VA/LOpDBghbwNLyPo1hmr0ge37KHO1+ZrvLb3cnMEI+FoU0A9lfGd7ZpaBvoCBVC +Ib2dDFvk0V+A63sDOj1o7YkAIpdZRUViLNi1oh3kTIuJ3SqqQJ8aRo1ebDaty2L2 +XV9haD5Sdx9hjIsrYM3a0muFYFgb8I5REXAd2ZysrNb2+X0ttBJlZT589Ens32bN +ZcFGJQ+eEAuCZopRDrfjiQ== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + + + + + + + + + + E523pHG09Q+dJPWK4g0Kcz4E8vVrwMTee56OeyxdbfA= + + + BiJiEs+RgSWWGBvD/pVoL3EaJbDd2jDZIN38+elnBucj1mfRyIazp/3m7SQEgA+S +TyhU+GfqYiJ90dWOmxKK41OliE90TkWwqkLgmfO8e0xcgBMnyDqL/KMk+D46xS07 +ZN+dKfRUgBr21LlMOSs8LH/xQ6aMJyZeAs3oNTpYKXDsT14RlKAJb5LDSsTt25/k +Xe5uVk8w15iZfCPQ10y8Z0srWWMaaQgK5od8O8AKKQ97YZI5qobbaPvO3Cf9/a2b +XeQ/u9xoTkFSTWi8KjDH2fO76UFEr4leyh7hTFiq5NX26QEV6kaM4pEVHhta4SO8 +piGX1lJZRs4TxaEpFtzgOw== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml new file mode 100644 index 00000000..7b28676e --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml @@ -0,0 +1,86 @@ + + + + + + + + + LruzvJ9DZFMg52TN27sjEyvVN/+8aupMC7iyaAmRzDI= + + + + + ybZ++lnCwgpeLdF6ZMqiXaXQtHqBgANIDPQSWUr+8Xc= + + + sBBSokcEcOX7X1b5AUYUlRNde7hPL7ITAdHJrewYLmYq69y+rjhPiL96lwJNGWdS +nFgavzNRxu2zigfJGpq57OHrmIn5p9yVc0bGMMlR+VV4wXsZiSkD+3nI5f/eQwZx +3iNlRGqb0B7FJmPqVoM503AToZt+LRtkCqJXzQjCZWJmaWd8mF6lPe8XsB4cYjQt +6GTgqKN4YNptfJW5kekAQMERao6LMIrxMJ6FEp6YNxpCSlwWemnehZQK3bGL5esf +GVl4FKmSSf3Qf3NSoHpx1FPgU+ROtMOeqD9ClpIiS+XQrsNpMrQbwabt7ylHRohD +u0CcM1alvxBQdlecGum9EQ== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/plain + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml new file mode 100644 index 00000000..107a118a --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFZAoBAKCCBV0wggVZBgkrBgEFBQcwAQEEggVKMIIFRjCBwKIWBBQ7nnoZmhqJ3zMre29INTIQzKLAqRgPMjAyNjEwMzExOTAwMTNaMIGUMIGRMGkwDQYJYIZIAWUDBAIBBQAEIDeIZrkLqw2jsvBbdxmiNHaeHKuaojYH5vL2H5OaxnxoBCC+gAFNfXMPXKAMVqTso9qtMYJWbKWhiAHxeujq27WK7QIUEtP+apS9r5y6gzIiabdnRXiOuCqAABgPMjAyNjEwMzExOTAwMTNaoBEYDzIwMzYxMDI4MTkwMDEzWjANBgkqhkiG9w0BAQsFAAOCAQEAuCAb8cYDyw/c8rq4W2MkNsyM2Ev4p97VP949hIpnQtu9s3Ol9Kk3smkdqDdN+VOFh440J4g45T/1wV8TuUXu2Yc4aUN5NCuGxyEqJmtaaFNNIgwQuoQaMj3SL2ak5NjqSSOn6OkXsjwLA37gVs/K8p/qecvirpSKwiiEgfKu2sdjl4SXC/2dRY5muhcwmeYu+EgN/kFBrQys30hQyriQxZP/PyfKRWHGIn6v+d0kDdS6cLdBsOUT1TAm7K8q/IhbgslJQ5xfxSMh0gLu8+RNm2dy612jXX5yaGSIc3yY2fmJ+xBcbjh23u1OY+KXUGwJk39xdsgvUO31XoRMjqHataCCA2swggNnMIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml new file mode 100644 index 00000000..29302cc5 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBrzCBmAIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgPjA8MB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMA0GA1UdGwEB/wQDAgEBMAoGA1UdFAQDAgECMA0GCSqGSIb3DQEBCwUAA4IBAQBYrGeJFcHEyEm1rU6h8LUt/k84nSlLz4Fl8fN3AmGSDl5kxsnuynFxpN55NWDRFeTK7bQCrBXcj4Qt4QTO02YnRnUtBt/5t/Wgsg7jfCjkcl21CDXPVPcjjXf14h3JzoAVntOHtqCZ1p5COsUtkdRS3irIUc8YdAIobYb4/JqHpNpO0j+c9X9xqMb1hw+LU+Qn2f43VhStiXEbDfArhIJgDb26iNuka/8RxAFDvse2tsXQ7nbU85LuDOd3xP5czLu/7F5jMpimNstbFHgWnhzv2WgegdZERAX6uxrhYFIjGmpOz28ehOgC/wslYH6R/B0TAwvanr/9qWJTvCnM6l86MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml new file mode 100644 index 00000000..389700be --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml new file mode 100644 index 00000000..39309122 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxNFoXDTM2MTAyODE5MDAxNFowJzAlAhQuLzvOU0+AV+t/Nr3QPSrE54WrrhcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBAKJNtyhIIJNuocMg7Q/pGov8lDhebX4Pmran+jNrCG/nClMZP6EZs7LBY9KKiEoZ+SSnQ9N+TrylBwLMTXNX9al27/GL6LkiuX6bK4CwSky8C/YitHeFBVPYBxuBh96SwdaeuKHBEBWXAQwSKxJ5RXiCYWCAsPezbst6NAuea1rv5twGp1CmKUmmejLfXIkzv55jAPnymsGyRPO98aaMO5sSrma9ccqqJ9eJzVQR25v6ImjRPElkqzd/OwWpb+x2kSl8MdZB4gGFlP+PpQtZTrpCZtSRgNGPje2li+3A1rj72bwl9EkbSjIPk8jYjU8u9HR4HOVtTGq+FwtvsAkepfQ=MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml new file mode 100644 index 00000000..81da6dad --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml new file mode 100644 index 00000000..afca8d5b --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml @@ -0,0 +1,87 @@ + +Manifest payload + + + + + + + + TFcB8ggy4C8MYuFs8k7jbHBZJ/dkAOQ82UW+I8pbflc= + + + + + t49QRjv1IEbVJSwLcyU80GKclR8apTuH9axSCxHXTHM= + + + e02s3B0M07f4iK6pyUuhmPHnX8dTBuFfEMPli5HTULP5EZpUD/0bE0vpeoVc6r5e +9O5fj9X/q4cUj2SLmRmUnKztqyS8fnkq/JkP5YQ+BIidDzwCQOZsZkO3s4e+fHfe +bon+MeIp9d3ikylOZGU6xrTxdvq6B8CcXIEFQp9aOJSkKQzl6JQzj0PpLcLg4R6e +nun3DyRz+Rq/wvgwN/lRrCkctbpmtYzibY+gc5+dLtivNGpyOZIN1VKH3NQM569u +aJQcXj4nlgvshxUUHtBBG+ocHr/8KuGVlFwgaGwhvqsPdBR4ORSorSAhDXRLVGYY +0hvf0A5rGK9lcx3bTsKwPg== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + LruzvJ9DZFMg52TN27sjEyvVN/+8aupMC7iyaAmRzDI= + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + text/plain + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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ihMagMmK8hAzA+28fMYKxTyNDPKqnQINKF39EuClVKR+BQQOTRF5SQ9KKu4wml22Lttwu29G4hYY2bMA/B3Cdw==TKmSHV1TEehk3y8Qcw/0cSFLNES710AvwKxhj/ELat4UXppZWdF0jyPOB5saB0axmyp6aipPTiWrTSE4JzG7UQ== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml new file mode 100644 index 00000000..dd54a7ab --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml new file mode 100644 index 00000000..7bc5e3ca --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml new file mode 100644 index 00000000..fc328613 --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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 + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml new file mode 100644 index 00000000..6b92902a --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml @@ -0,0 +1,171 @@ + +First payloadSecond payload + + + + + + + + ItRTyDuH5xXvQL3uaMr3VBlLiBXu0FS2v4taDaixIa4= + + + + + RxQWAG1yIIJJlD/GQaZIR6mD3ZqF1dJFBurNLuZ5PGc= + + + l2A9ubvznY0hYnFa1jx9MtSgUfVR/6a4aqB8Dp5w6McQagVjRTcwP+GVQrsYBn8a +E6Q1OAiEEoeW6W3WKQV3xtcy/q+KzSrAE/thgcOwRkxivuh6IjfP2EDbq1qirF/d +y/X/DjLq5fOogGY00mpuiKHrT2fkd84+kDffsgwsZTZHQOLt3hQxBpqjFGYkj7CR +9XYGacVNScnHtZ6IE3Ssp/LokBszRYUkxL0nfHcv9a5Od3ETmqBmIfEDMGitlBRj +mtRNF4BsiBf5LIuI+6kQueDmzedp1HQ5jSupWAbA7Nz+PbfVWeB1QGDbNyTwD1mO +/0l217BzeynS9mPzG2rC9A== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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 + + + + + + + + + + 4SLXFWhdBHi4t5m93/fr1n8ZEKJzjR2A3kbMckaKPZQ= + + + + + kthBYSER4HIKUkjDSUozx1OURGGv9mgcsswe2cPDG7k= + + + gyyJ3Gs7m9qc9Q1XNorm5qJZtq2kWtiEYinov/RZuxspGbokjMm/0ki/mXIhC/ze +TEIpIBenwsg/w7tIKZPB2Coocmm9ZEt0kq2W1MnS2PDg2ORqwm0/UZVBV3OzFzUX +yTJ65yygTnmLJCAk+AzszxOk64nb8YdMGpIVO6i6B2jpIA5CuSAGbD3Tns3CMMKk ++aifRyQewBChi2Bq1XrGnUoqNSmBuPtsW+d6i9AXqfdzMF86COc/KFoclYCkvTUD +Y1hkwc7YY6X4fm+sOnHllgW63AXWyN7xslHKVdsvlLmExpbWvuMwNH+Pn3aVKpB8 +mM+hd5A6rHYV4LMkpdqUtg== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + 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 + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml new file mode 100644 index 00000000..309a163f --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + + + p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq +698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ +EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ +Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr +5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY +PG19u661UV3b/B9UY30wug== + MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb +KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N +BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui +lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV +LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR +ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j +BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa +gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX +NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D +2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l +kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt +q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr +4Z4RqnYHsCZ4cWOSXyc= + +MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c +mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 +Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y +YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE +ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY +dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G +A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB +AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv +XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz +bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ +YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy +z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ +ARrAZvqlC+ytq8wqC7ARLBIl + + + + + + + 2026-10-18T12:00:00Z + + + + + jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + + + + + + + text/xml + + + + + MIIGAAYJKoZIhvcNAQcCoIIF8TCCBe0CAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgLNHl9YZhWSmrjaj1lmeEUQuLXNYMtfTIdN2EQJl8yj4CAQIYDzIwMjYxMDMxMTkwMDEzWjADAgEBoIIDUzCCA08wggI3oAMCAQICFC4vO85TT4BX6382vdA9KsTnhauuMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCMxITAfBgNVBAMMGHhtbC1zZWMgWEFkRVMgTGV2ZWxzIFRTQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ5lcp6jEjevARbPMn130qbDW7xdm0WKLgNzc/++nx5rITeDYKO+iNjBKBSloDoHBwseuN6Cf7sULAmPeeooFkU/Jne6A1z1iWfmqKJhvW0Qo28e17lB8zJfnwXSlkDAbr/Wau8xjKQYVFDebdSSOmtgvyDz1W/rTPss7CSFlLxItx0PAx4US9pv2UPKoZxbiJGjah3gDx64DhmUMkvsYW/A0HWclU9Qe4ThuoclIIiFIohEobzXcgxiz37CTqyHQR3i8cAL2fmvABVlBfxv/XjqbmJd6B3due/hXA4iA0tkhScHXrZl9JF5yum9oTyFVG9yi3Okr/JEt7P/7xX/GpUCAwEAAaN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFKu/njCfigLBibaZFqEvnVrTseoEMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMA0GCSqGSIb3DQEBCwUAA4IBAQAZKeN+eE7IHI+B7QF0GdDqKVDvBlmjrb5/dO3gthoY2j/ulruBDmkpCF0o4GZg5KDbRLo22BV4V6Vq8cYIN2XYCj/ssLV9r8rnQuPi9oeu5mQNXncekxTO+IDdLsQIZNeN4QKXdf0zatKUfjIyBWebBOxAdOl1OE/pr4CEHUkJJ2bpKyk/YJy8P+o66u/DCoGxAnf1OVW1Y7va27Gms5dM+PRgSK9vsQtCT+YN/l6jkTYWj/uvkgDJE3oDGCl4Ea4+1gbfdWuzQcY1kDAGVC/ul2GjXUCweJ4iceRnK/X2R8OEiGW2segTWFNYg+s2z31qtgsoHUJE+ZFhvGb3cc/HMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFC4vO85TT4BX6382vdA9KsTnhauuMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMTkwMDEzWjAvBgkqhkiG9w0BCQQxIgQgS5NlUwfQR7XGWuBk1Z8JUEww5tN9JGUlW//YyUUXnLcwNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUOP4nhD0v9FR++FXdpq+OQ7CdFF31MrUcQjPBt9Gl3IwDQYJKoZIhvcNAQEBBQAEggEAMHRV6vLlA779bo9KWnOQje7lS61Xxdl2rQR06zLXI3WRfhYm9mPG7kSzNRJs6BQ6epJwvNBnscEUBFKyKSZ1125IoAyDrsKCVbpjUWdBxACBFsO0ITp610iE15qfkiqOycFsu9PuAqqzxAqcZhPCF5MK/JEnS5uvV9V9aGw9v794EYT08Js9Vu/KdR151FJuObH9G5BYW8BftHBy2725RoqHG/IPWSYYsmA2ZyjSHLtXrmo2tPn3iUwIRCLMoB72XbAUSkMuj1O+MC7kNS0V1w0wuUNLTh1uEkQ9x9xZjz+aDx3cn+LQ5/91QbnxoHgfx2eh0mOYtmyjvakLRqbaVA== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/detached.txt b/crates/xml-sec-xades/tests/fixtures/levels/detached.txt new file mode 100644 index 00000000..a96a532f --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/detached.txt @@ -0,0 +1 @@ +Detached levels payload diff --git a/crates/xml-sec-xades/tests/fixtures/levels/issuer.der b/crates/xml-sec-xades/tests/fixtures/levels/issuer.der new file mode 100644 index 0000000000000000000000000000000000000000..afb67f4f71f337767ef556fc7bea3542cf52896f GIT binary patch literal 834 zcmXqLVzx7AVp3bc%*4pVB%*vNt*O^iy&4q#+uU~XdMX8?+GF*PwVGVGFNU<%B+ z@?KKKGUN`UOu4?akJPq5-wz5+{eS7A$hHU73_UZ{rZsRhXIPi@+Rd5yY1R|}()wvL zXNF(Qy(7>2E6BR=v6l+Nt^CJx?>{>2c_92v;p_SQYkO8K-Nv!$Vu>-^8`Nxcw zXz%%S`Hl6XA6%uPOyOL!^)G}L-QtVdyRhNZDNz+ivpsQ@b!;xFf1-oZ{oK!9;$@ql zyj|6O|7+Jf4{x2n8GWYfV(wyzfV$w$AQ>;?gWC05yDTitXOvx&yvOS3;Z#$C#n zJq3H2m>C%u7pEDd7zhDFQ&yOf@jnZP0UMBFVq`Gj1Bvm2#8`k4%w`}9;`6bHv4}7j zJ8Q3yp7-vX`cHBPSxMtzE1IMSvIlf=)6s>q3 zIVONf0T>gE45>Q|9!!k=`B`MkBG1&T=H`=U8pSX0IUsiMr?Hc*($2hPb>Hu6pL-B= zbDsU3NAF`U+MWBW?wYgw%%%OSj(Hl2U5uXeK(Oz$-X25o8fLMtR@bJLw(k*XUr@9o zH!+K=IM0D=m(hWQ$Q-F3esN|i+b-W|4c6G!7(Xr6L;t5-*rs=}!FKBpf4n_G(f#Cn ztEVRuZce(lDB!TL@1MDS^K1U*{(a_@T*jSqzlihF-hAIMvHrcppK9#0A}n_1^@s6 literal 0 HcmV?d00001 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/outsider.der b/crates/xml-sec-xades/tests/fixtures/levels/outsider.der new file mode 100644 index 0000000000000000000000000000000000000000..706a1364c546f47bbe7a96ff6d11d3800160233d GIT binary patch literal 861 zcmXqLVvaOuVsc!-%*4pVBvMetke(mJaAs1~WVcBhulx0$zLH|V%f_kI=F#?@mywa1 zmBB#8P{}}njX9KsnMblBH%GTPHCZ9TF~v1l!6&sWHK$l1C_lf%Ku(<3$jrbH2*Dsq zoY%w@iEE&5sB54NF+~NdDbD$MX_@JzMX4zY{?5Sx22G4g$Sz@IWngY%%VyXm(xZ^a&P-QSKjZl@Z|iwv$JY!e15s7ZCkhDY2H^8 zC5ca2I;W?E@Yy`w+RqyE@@7M*&XG3r-V)!B&HJ4~zv>rw&J;{|>rgDS!BNhurow#p zY9*(g?yDT8r>noQ&FzlvMjeg|Cd+y@ z#9U%?+MdHJFRk&DiJ6gsadCw~nE?+lSY?G78UM2|888^|fq48N9t$%QdxL=(h_4Fb z^B8ckacHwKva+%>a~jBk#Q9jnSVXoQ*n8ORzr}Apm1L`iHBPSxMtzE1IMSvIlf=)6s>q3Ic|Wd1Q<7r40EO37P4JZ?fjayGwe@mAC7}g)=;NI`2Bc8ydWKm(L?^ms~Z~Kc6C8KJRL` zVzPHq&uy)8dQ|6rK*fUVJy;U2a?) vruIVPuW#uAuWA9iRr+USR>~h_Ic2yaBPPecU}C*k)Iy&Z21{%YKRF8kS4C4E literal 0 HcmV?d00001 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/root.der b/crates/xml-sec-xades/tests/fixtures/levels/root.der new file mode 100644 index 0000000000000000000000000000000000000000..d3e2e8b3f215fee65e0bb6202c423f60c9bd849e GIT binary patch literal 796 zcmXqLVwNyyVq#dp%*4pVB*OMb_hCF!%5J+WtUoWx=gnW+_A}3bmyJ`a&7C*ni!Rkt!HFqU~XdMXE11DN0a{@$nH$$)5-ia?f;uAThFDR@q4ap@ z^V`}Vwn<{V_4D21U#pqsGws;B`>$He<9}ZQ>=#MYA3ZHUW$A$v7Pb8^g%xv3T}{l) zq}M%ICi-xKc)NLrYY@jnZz0W**?-~$Qpg9KQB zQO|}P%D_klhB6~V{Uh_$rf;UPMJFXcpT*RCqWa8(N!^^6LpiSRdw0&|Wur&H6n-vE zsax@KzudhPe}Dh6a!JgRCAR&33raQZ8wEYLoKop$d&|QuCU7bEmQ|{8&mu3Yn^D&8 zpSQg}tK8n~IA@CbU;bq)qz{HylwR6>{NBNDSygv@4={xvb9m$L?KWk?jrjtV+xJJE zdUbgz>w*W&6D4A+%ztxe*T(&jTK>23jf2#&uKs4hnNhFR*8Gg!F7vr>lE}ON`NulM z9y|-Hd$j$(dfgT4Jab-wiWi4Z<=w8A*?y{FTl|w(%b!WfF8Vj6HedOTN$%IsBFCaY bMGH3my%SH~Hhg=|L-E9>Ga<{a91R8lPt`|p literal 0 HcmV?d00001 diff --git a/crates/xml-sec-xades/tests/levels.rs b/crates/xml-sec-xades/tests/levels.rs new file mode 100644 index 00000000..124839d7 --- /dev/null +++ b/crates/xml-sec-xades/tests/levels.rs @@ -0,0 +1,865 @@ +//! B-T, B-LT and B-LTA validation of independently produced signatures. +//! +//! `xml-sec-tools xades fixtures --levels` builds the fixtures: OpenSSL issues +//! every certificate, CRL, OCSP response and RFC 3161 token, libxml2 computes +//! each timestamp input and xmlsec1 the XML signature. + +use std::collections::BTreeMap; +use std::sync::Arc; + +use base64::Engine as _; +use base64::engine::general_purpose::STANDARD; +use structured_asn1::Oid; +use structured_asn1::memory::{Memory, MemoryAccount}; +use structured_cms::timestamp::{Accuracy, PolicyAccuracy}; +use structured_ltv::pki::{CrlReading, MemberStatus}; +use structured_pkix::crl::{CombinedEntry, EntryLookup}; +use structured_pkix::temporal::LeapTable; +use structured_xades::baseline::Evidence; +use xml_sec::XmlDocument; +use xml_sec::policy::{Instant, ManifestProcessing, VerificationPolicy}; +use xml_sec::xmldsig::{ + DefaultKeyResolver, DsigError, KeyResolverConfig, UriTypeSet, VerificationRequest, + VerifyContext, with_verified_request, +}; +use xml_sec_xades::{ + AuthorityAccuracy, ConfiguredResponder, Inputs, Level, Outcome, RenewalFailure, Requirements, + StatusFailure, TimestampFailure, TokenProfile, ValidationError, validate, +}; + +const ROOT: &[u8] = include_bytes!("fixtures/levels/root.der"); +const ISSUER: &[u8] = include_bytes!("fixtures/levels/issuer.der"); +const OUTSIDER: &[u8] = include_bytes!("fixtures/levels/outsider.der"); +const B_LT_CONFIGURED: &str = include_str!("fixtures/levels/b-lt-configured-responder.xml"); +const B_LT_CONFLICTING: &str = include_str!("fixtures/levels/b-lt-conflicting-status.xml"); +const B_LT_CONFLICTING_DELTA: &str = include_str!("fixtures/levels/b-lt-conflicting-delta.xml"); +const B_LT_TSA_DELTA: &str = include_str!("fixtures/levels/b-lt-tsa-delta.xml"); +const B_LTA_RENEWED_DIGESTS: &str = include_str!("fixtures/levels/b-lta-renewed-digests.xml"); +const B_T: &str = include_str!("fixtures/levels/b-t.xml"); +const B_T_NO_ACCURACY: &str = include_str!("fixtures/levels/b-t-no-accuracy.xml"); +const B_LT: &str = include_str!("fixtures/levels/b-lt.xml"); +const B_LT_MISPLACED: &str = include_str!("fixtures/levels/b-lt-tsa-material-misplaced.xml"); +const B_LT_REVOKED: &str = include_str!("fixtures/levels/b-lt-tsa-revoked.xml"); +const B_LT_DETACHED: &str = include_str!("fixtures/levels/b-lt-detached.xml"); +const B_T_PARALLEL: &str = include_str!("fixtures/levels/b-t-parallel.xml"); +const B_LT_COUNTERSIGNED: &str = include_str!("fixtures/levels/b-lt-countersigned.xml"); +const B_LT_BY_KEY: &str = include_str!("fixtures/levels/b-lt-responder-by-key.xml"); +const B_LTA: &str = include_str!("fixtures/levels/b-lta.xml"); +const B_LTA_RENEWED: &str = include_str!("fixtures/levels/b-lta-renewed.xml"); +const DETACHED: &[u8] = include_bytes!("fixtures/levels/detached.txt"); + +/// `1.3.6.1.4.1.13762.3`, the policy of the test TSA. +const LEVELS_POLICY: &[u8] = &[0x2b, 0x06, 0x01, 0x04, 0x01, 0xeb, 0x42, 0x03]; +/// `1.3.6.1.4.1.13762.4`, a policy no fixture token states. +const OTHER_POLICY: &[u8] = &[0x2b, 0x06, 0x01, 0x04, 0x01, 0xeb, 0x42, 0x04]; + +/// Unix time `1_800_000_000`, inside every fixture certificate and CRL window. +const AT: i64 = 500_000 * 3600; + +/// The caller evidence of one validation, beyond its UTC facts and level. +#[derive(Default)] +struct Given<'a> { + anchors: &'a [&'a [u8]], + certificates: &'a [&'a [u8]], + accuracies: &'a [AuthorityAccuracy<'a>], + responders: &'a [ConfiguredResponder<'a>], + crls: &'a [&'a [u8]], + responses: &'a [&'a [u8]], + /// [`TokenProfile::Etsi`] unless a case asks for the CMS reading. + cms: bool, +} + +/// `Memory` capacity and work ceiling of an ordinary validation. +const AMPLE: (usize, usize) = (1 << 25, 1 << 31); + +/// `visitor` over `requirements` of the first signature of `xml` on an account +/// with these `(memory, work)` ceilings, or what stopped it. +fn level_in( + xml: &str, + requirements: Requirements, + given: &Given<'_>, + (memory, work): (usize, usize), + visitor: impl for<'a> FnOnce(&Level<'a>) -> R, +) -> Result, ValidationError>, DsigError> { + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: vec![ROOT.to_vec()], + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Instant::new(AT, 0); + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(xml).expect("fixture parses"); + let request = VerificationRequest::default(); + let account = Memory::new(Arc::new(MemoryAccount::new(memory, work))); + let utc = LeapTable::new(-2_208_988_800, 4_102_444_800, &[]).expect("UTC coverage"); + with_verified_request(&document, &context, &request, &account, |session| { + let signature = session.evidence().signatures()[0].identity(); + let inputs = Inputs { + requirements, + token_profile: if given.cms { + TokenProfile::Cms + } else { + TokenProfile::Etsi + }, + anchors: given.anchors, + certificates: given.certificates, + utc: &utc, + accuracies: given.accuracies, + responders: given.responders, + crls: given.crls, + responses: given.responses, + }; + Ok(validate(&session, signature, &inputs, visitor)) + }) +} + +fn level( + xml: &str, + requirements: Requirements, + anchors: &[&[u8]], + certificates: &[&[u8]], +) -> Result, ValidationError> { + met( + xml, + requirements, + &Given { + anchors, + certificates, + ..Given::default() + }, + ) +} + +fn stated( + xml: &str, + requirements: Requirements, + anchors: &[&[u8]], + certificates: &[&[u8]], + accuracies: &[AuthorityAccuracy<'_>], +) -> Result, ValidationError> { + met( + xml, + requirements, + &Given { + anchors, + certificates, + accuracies, + ..Given::default() + }, + ) +} + +fn all_met(level: &Level<'_>) -> bool { + level.all_requirements_met() +} + +fn met( + xml: &str, + requirements: Requirements, + given: &Given<'_>, +) -> Result, ValidationError> { + level_in(xml, requirements, given, AMPLE, all_met).expect("fixture verifies as XMLDSig") +} + +#[test] +fn a_real_timestamp_token_meets_b_t() { + // OpenSSL's TSA stamped libxml2's canonical SignatureValue: the imprint, + // the CMS signature and the TSA path to the caller's anchor all hold. + let result = level(B_T, Requirements::Timestamped, &[ROOT], &[]); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +#[test] +fn incorporated_crl_and_delegated_ocsp_meet_b_lt() { + // The signer's status is a delegated OCSP response whose noCheck responder + // and every CA have their own status in the document. + let result = level(B_LT, Requirements::LongTerm, &[ROOT], &[]); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +#[test] +fn timestamp_material_outside_its_containers_fails_b_lt() { + // EN 319 132-1 §6.3(x): every status is usable and incorporated, but the + // TSA's own material sits in the ordinary signature values. + let result = level(B_LT_MISPLACED, Requirements::LongTerm, &[ROOT], &[]); + assert!(matches!(result, Ok(Outcome::Assessed(false))), "{result:?}"); +} + +#[test] +fn a_real_archive_timestamp_meets_b_lta() { + // The archive token covers libxml2's output for every reference, the + // signature and all earlier validation material. + let result = level(B_LTA, Requirements::Archival, &[ROOT], &[]); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +/// `xml` with one base64 character of the `ordinal`-th token changed, far enough +/// in to land in signed content rather than the outer CMS framing. +fn tampered_token(xml: &str, ordinal: usize) -> String { + let open = ""; + let start = xml.match_indices(open).nth(ordinal).expect("token").0 + open.len(); + let at = start + 400; + let replacement = if &xml[at..=at] == "A" { "B" } else { "A" }; + format!("{}{replacement}{}", &xml[..at], &xml[at + 1..]) +} + +/// The base64 value of the `ordinal`-th token. +fn token_value(xml: &str, ordinal: usize) -> &str { + let open = ""; + let start = xml.match_indices(open).nth(ordinal).expect("token").0 + open.len(); + let end = start + xml[start..].find('<').expect("token end"); + &xml[start..end] +} + +#[test] +fn both_token_profiles_meet_every_level_on_der_tokens() { + // A DER token is valid BER, so the CMS reading changes nothing for it. + for (xml, requirements) in [ + (B_T, Requirements::Timestamped), + (B_LT, Requirements::LongTerm), + (B_LTA, Requirements::Archival), + ] { + let given = Given { + anchors: &[ROOT], + cms: true, + ..Given::default() + }; + let result = met(xml, requirements, &given); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); + } +} + +#[test] +fn a_changed_token_never_yields_evidence() { + // A change inside the signed token breaks its CMS signature or its imprint. + let result = level( + &tampered_token(B_T, 0), + Requirements::Timestamped, + &[ROOT], + &[], + ); + assert!( + matches!( + result, + Ok(Outcome::Timestamp { + failure: TimestampFailure::Rejected, + .. + }) | Err(ValidationError::Timestamp(_)) + ), + "{result:?}" + ); +} + +#[test] +fn another_input_token_in_the_archive_position_is_refused() { + // The signature token is genuine, but it covers the SignatureValue rather + // than the archive input, so its imprint must not satisfy the archive. + let forged = B_LTA.replace(token_value(B_LTA, 1), token_value(B_LTA, 0)); + let result = level(&forged, Requirements::Archival, &[ROOT], &[]); + assert!( + matches!( + result, + Ok(Outcome::Timestamp { + failure: TimestampFailure::Rejected, + .. + }) + ), + "{result:?}" + ); +} + +#[test] +fn a_member_without_any_status_stops_b_lt() { + // With every OCSP response and CRL removed, the first path member has no + // source. That is a missing input, not a statement about revocation. + let start = B_LT.find("").expect("values"); + let close = ""; + let end = B_LT.find(close).expect("validation data") + close.len(); + let stripped = format!("{}{}", &B_LT[..start], &B_LT[end..]); + let result = level(&stripped, Requirements::LongTerm, &[ROOT], &[]); + assert!( + matches!(result, Ok(Outcome::Status(StatusFailure::NoSource))), + "{result:?}" + ); +} + +#[test] +fn requesting_a_level_the_document_lacks_is_not_promotion() { + // A B-T document has no validation material, and a B-LT one no archive: + // neither is reported as the level it does not reach. + let result = level(B_T, Requirements::LongTerm, &[ROOT], &[]); + assert!( + matches!(result, Ok(Outcome::Status(StatusFailure::NoSource))), + "{result:?}" + ); + let result = level(B_LT, Requirements::Archival, &[ROOT], &[]); + assert!( + matches!(result, Err(ValidationError::Prepare(_))), + "{result:?}" + ); +} + +#[test] +fn a_revoked_timestamp_authority_stays_a_fact_of_the_report() { + // The material is complete, so the structural level holds; the TSA's + // status must not disappear behind that, and is no absence evidence. + let revoked = level_in( + B_LT_REVOKED, + Requirements::LongTerm, + &Given { + anchors: &[ROOT], + ..Given::default() + }, + AMPLE, + |level| { + let Evidence::LongTerm(report) = level.evidence() else { + panic!("a B-LT request yields the B-LT reports"); + }; + let nodes = report.x509().timestamps().inputs().authorities().nodes(); + nodes + .iter() + .flat_map(|node| node.statuses.entries()) + .any(|status| { + matches!(status, MemberStatus::CrlReading(reading) + if matches!(reading.reading(), CrlReading::Complete(facts) + if matches!(facts.entry(), EntryLookup::Found(_)))) + }) + }, + ) + .expect("fixture verifies as XMLDSig"); + assert!( + matches!(revoked, Ok(Outcome::Assessed(true))), + "{revoked:?}" + ); +} + +#[test] +fn a_crl_entry_is_not_hidden_by_a_good_ocsp_response() { + // Conflicting evidence: OCSP says good, a complete CRL lists the signer. + // The listed entry must reach the report rather than the answer read first. + let listed = level_in( + B_LT_CONFLICTING, + Requirements::LongTerm, + &Given { + anchors: &[ROOT], + ..Given::default() + }, + AMPLE, + |level| { + let Evidence::LongTerm(report) = level.evidence() else { + panic!("a B-LT request yields the B-LT reports"); + }; + report + .x509() + .timestamps() + .inputs() + .authorities() + .nodes() + .iter() + .flat_map(|node| node.statuses.entries()) + .any(|status| { + matches!(status, MemberStatus::CrlReading(reading) + if matches!(reading.reading(), CrlReading::Complete(facts) + if matches!(facts.entry(), EntryLookup::Found(_)))) + }) + }, + ) + .expect("fixture verifies as XMLDSig"); + assert!(matches!(listed, Ok(Outcome::Assessed(true))), "{listed:?}"); +} + +#[test] +fn a_delta_entry_is_not_hidden_by_a_good_ocsp_response() { + // RFC 5280 §5.2.4: only the delta names the signer; its complete base does not. + let listed = level_in( + B_LT_CONFLICTING_DELTA, + Requirements::LongTerm, + &Given { + anchors: &[ROOT], + ..Given::default() + }, + AMPLE, + |level| { + let Evidence::LongTerm(report) = level.evidence() else { + panic!("a B-LT request yields the B-LT reports"); + }; + report + .x509() + .timestamps() + .inputs() + .authorities() + .nodes() + .iter() + .flat_map(|node| node.statuses.entries()) + .any(|status| { + matches!(status, MemberStatus::CrlReading(reading) + if matches!(reading.reading(), CrlReading::Delta(facts) + if !matches!(facts.entry(), + CombinedEntry::Absent | CombinedEntry::Removed { .. }))) + }) + }, + ) + .expect("fixture verifies as XMLDSig"); + assert!(matches!(listed, Ok(Outcome::Assessed(true))), "{listed:?}"); +} + +#[test] +fn a_delta_in_the_timestamp_validation_data_is_coverage() { + // §6.3(x): the TSA's complete CRL and its delta both sit in the timestamp's + // own validation data. The delta is an actual input, not an ignored extra: + // the census holds exactly one artifact more than the same chain without it. + let artifacts = |xml| { + let given = Given { + anchors: &[ROOT], + ..Given::default() + }; + level_in(xml, Requirements::LongTerm, &given, AMPLE, |level| { + let Evidence::LongTerm(report) = level.evidence() else { + panic!("a B-LT request yields the B-LT reports"); + }; + ( + level.all_requirements_met(), + report.x509().presence().entries().len(), + ) + }) + .expect("fixture verifies as XMLDSig") + }; + let plain = artifacts(B_LT); + let with_delta = artifacts(B_LT_TSA_DELTA); + let (Ok(Outcome::Assessed((true, plain))), Ok(Outcome::Assessed((true, with_delta)))) = + (plain, with_delta) + else { + panic!("both fixtures meet B-LT"); + }; + assert_eq!(with_delta, plain + 1); +} + +/// `xml` at B-LTA with its `Manifest` processed and these detached bytes supplied. +fn renewal(xml: &str, detached: Option<&[u8]>) -> Result, ValidationError> { + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: vec![ROOT.to_vec()], + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Instant::new(AT, 0); + policy.uris.references = UriTypeSet::ALL; + policy.manifest_processing = ManifestProcessing::Process; + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(xml).expect("fixture parses"); + let resources: BTreeMap> = detached + .map(|bytes| ("detached.txt".to_owned(), bytes.to_vec())) + .into_iter() + .collect(); + let request = VerificationRequest { + external_resources: Some(&resources), + ..VerificationRequest::default() + }; + let account = Memory::new(Arc::new(MemoryAccount::new(AMPLE.0, AMPLE.1))); + let utc = LeapTable::new(-2_208_988_800, 4_102_444_800, &[]).expect("UTC coverage"); + with_verified_request(&document, &context, &request, &account, |session| { + let signature = session.evidence().signatures()[0].identity(); + let anchors: &[&[u8]] = &[ROOT]; + let inputs = Inputs { + requirements: Requirements::Archival, + token_profile: TokenProfile::Etsi, + anchors, + certificates: &[], + utc: &utc, + accuracies: &[], + responders: &[], + crls: &[], + responses: &[], + }; + Ok(validate(&session, signature, &inputs, all_met)) + }) + .expect("fixture verifies as XMLDSig") +} + +/// `B_LTA_RENEWED_DIGESTS` with the content of `tag` changed in its first byte. +fn changed_renewal(tag: &str) -> String { + let open = format!(""); + let at = B_LTA_RENEWED_DIGESTS.find(&open).expect("value") + open.len(); + let replacement = if &B_LTA_RENEWED_DIGESTS[at..=at] == "A" { + "B" + } else { + "A" + }; + format!( + "{}{replacement}{}", + &B_LTA_RENEWED_DIGESTS[..at], + &B_LTA_RENEWED_DIGESTS[at + 1..] + ) +} + +#[test] +fn renewed_digests_confirm_the_detached_object() { + // EN 319 132-1 §5.5.3 under SHA-512, over a Manifest digested with SHA-256. + let result = renewal(B_LTA_RENEWED_DIGESTS, Some(DETACHED)); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +#[test] +fn a_renewal_that_disagrees_stops_the_level() { + // §5.5.3 notifications stay typed facts: a wrong new digest, and a reference + // digest naming no instruction. + for (tag, expected) in [ + ("NewSDODigestValue", RenewalFailure::Differs), + ("OriginalRefDigest", RenewalFailure::Unbound), + ] { + let result = renewal(&changed_renewal(tag), Some(DETACHED)); + assert!( + matches!(result, Ok(Outcome::Renewal { failure, .. }) if failure == expected), + "{expected:?}: {result:?}" + ); + } +} + +#[test] +fn a_detached_object_nobody_supplied_stops_before_its_renewal() { + // The signed Manifest reference itself cannot be established, so §6.3(k) + // refuses at preparation and no renewal is reached. + let result = renewal(B_LTA_RENEWED_DIGESTS, None); + assert!( + matches!(result, Err(ValidationError::Prepare(_))), + "{result:?}" + ); +} + +/// Whether every signature of `xml` reaches `requirements`, given its resources. +fn every_signature(xml: &str, requirements: Requirements) -> Vec { + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: vec![ROOT.to_vec()], + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Instant::new(AT, 0); + policy.uris.references = UriTypeSet::ALL; + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(xml).expect("fixture parses"); + let resources = BTreeMap::from([("detached.txt".to_owned(), DETACHED.to_vec())]); + let request = VerificationRequest { + external_resources: Some(&resources), + ..VerificationRequest::default() + }; + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 25, 1 << 31))); + let utc = LeapTable::new(-2_208_988_800, 4_102_444_800, &[]).expect("UTC coverage"); + with_verified_request(&document, &context, &request, &account, |session| { + let anchors: &[&[u8]] = &[ROOT]; + let inputs = Inputs { + requirements, + token_profile: TokenProfile::Etsi, + anchors, + certificates: &[], + utc: &utc, + accuracies: &[], + responders: &[], + crls: &[], + responses: &[], + }; + Ok(session + .evidence() + .signatures() + .iter() + .map(|entry| { + let outcome = validate(&session, entry.identity(), &inputs, |level| { + level.all_requirements_met() + }); + format!("{outcome:?}") + }) + .collect()) + }) + .expect("fixture verifies as XMLDSig") +} + +#[test] +fn a_token_without_stated_accuracy_is_a_rejected_timestamp() { + // RFC 3161 §2.4.2: without accuracy the generation interval is unknown, so + // the token is a completed negative fact, never a guessed interval. + let result = level(B_T_NO_ACCURACY, Requirements::Timestamped, &[ROOT], &[]); + assert!( + matches!( + result, + Ok(Outcome::Timestamp { + failure: TimestampFailure::Rejected, + .. + }) + ), + "{result:?}" + ); +} + +/// The test TSA's certificate, the first one of the timestamp's validation data. +fn tsa_certificate() -> Vec { + let data = B_LT + .find("") + .expect("data"); + let open = ""; + let start = data + B_LT[data..].find(open).expect("certificate") + open.len(); + let end = start + B_LT[start..].find('<').expect("certificate end"); + STANDARD.decode(&B_LT[start..end]).expect("base64") +} + +fn stated_second<'a>(policy: &'a [u8], authority: &'a [u8]) -> AuthorityAccuracy<'a> { + AuthorityAccuracy { + authority, + stated: PolicyAccuracy::new(Oid::from_bytes(policy), Accuracy::new(1, 0, 0)) + .expect("accuracy"), + } +} + +#[test] +fn caller_policy_accuracy_gives_an_unstated_token_its_interval() { + // RFC 3161 §2.4.2: the TSA's policy may define accuracy instead of the token. + let tsa = tsa_certificate(); + let result = stated( + B_T_NO_ACCURACY, + Requirements::Timestamped, + &[ROOT], + &[], + &[stated_second(LEVELS_POLICY, &tsa)], + ); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +#[test] +fn policy_accuracy_binds_the_signed_policy_and_the_authority() { + // The accuracy of another policy, or of another authority, says nothing about + // this token: it stays a completed negative fact, not a guessed interval. + let tsa = tsa_certificate(); + for entry in [ + stated_second(OTHER_POLICY, &tsa), + stated_second(LEVELS_POLICY, ROOT), + ] { + let result = stated( + B_T_NO_ACCURACY, + Requirements::Timestamped, + &[ROOT], + &[], + &[entry], + ); + assert!( + matches!( + result, + Ok(Outcome::Timestamp { + failure: TimestampFailure::Rejected, + .. + }) + ), + "{result:?}" + ); + } +} + +#[test] +fn an_unlisted_policy_does_not_disturb_a_token_stating_accuracy() { + // The token's own field comes first, so an entry for another policy of the + // same authority is simply not selected. + let tsa = tsa_certificate(); + let result = stated( + B_T, + Requirements::Timestamped, + &[ROOT], + &[], + &[stated_second(OTHER_POLICY, &tsa)], + ); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +/// `B_LT_CONFIGURED` at B-LT, given these configured responders. +fn configured(responders: &[ConfiguredResponder<'_>]) -> Result, ValidationError> { + met( + B_LT_CONFIGURED, + Requirements::LongTerm, + &Given { + anchors: &[ROOT], + responders, + ..Given::default() + }, + ) +} + +/// Every base64 value of `tag` in `xml`. +fn encapsulated(xml: &str, tag: &str) -> Vec> { + let open = format!(""); + xml.match_indices(&open) + .map(|(start, _)| { + let body = start + open.len(); + let end = body + xml[body..].find('<').expect("value end"); + STANDARD.decode(&xml[body..end]).expect("base64") + }) + .collect() +} + +#[test] +fn caller_status_answers_without_counting_as_incorporated() { + // The document has no status, so it stops; the caller's own CRLs and OCSP + // response answer it, but EN 319 132-1 B-LT still needs them in the document. + let crls = encapsulated(B_LT, "EncapsulatedCRLValue"); + let responses = encapsulated(B_LT, "EncapsulatedOCSPValue"); + let crls: Vec<&[u8]> = crls.iter().map(Vec::as_slice).collect(); + let responses: Vec<&[u8]> = responses.iter().map(Vec::as_slice).collect(); + let tsa = tsa_certificate(); + let certificates: &[&[u8]] = &[ISSUER, &tsa]; + let given = Given { + anchors: &[ROOT], + certificates, + crls: &crls, + responses: &responses, + ..Given::default() + }; + let result = met(B_T, Requirements::LongTerm, &given); + assert!(matches!(result, Ok(Outcome::Assessed(false))), "{result:?}"); +} + +#[test] +fn unreadable_caller_status_is_refused() { + let result = met( + B_LT, + Requirements::LongTerm, + &Given { + anchors: &[ROOT], + crls: &[b"not a CRL"], + ..Given::default() + }, + ); + assert!( + matches!(result, Err(ValidationError::Status(_))), + "{result:?}" + ); +} + +#[test] +fn a_responder_outside_the_issuer_counts_only_when_configured() { + // RFC 6960 §4.2.2.2: the document's response alone authorizes nothing, and + // configuring it for another issuer does not reach this certificate. The + // signer then falls back to the issuer CRL, which only the timestamp's own + // validation data carries: the level stays unmet. + assert!(matches!(configured(&[]), Ok(Outcome::Assessed(false)))); + let result = configured(&[ConfiguredResponder { + responder: OUTSIDER, + issuer: ROOT, + }]); + assert!(matches!(result, Ok(Outcome::Assessed(false))), "{result:?}"); + let result = configured(&[ConfiguredResponder { + responder: OUTSIDER, + issuer: ISSUER, + }]); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + +#[test] +fn a_detached_signature_reaches_b_lt_over_its_supplied_bytes() { + assert_eq!( + every_signature(B_LT_DETACHED, Requirements::LongTerm), + ["Ok(Assessed(true))"] + ); +} + +#[test] +fn each_parallel_signature_has_its_own_timestamp() { + assert_eq!( + every_signature(B_T_PARALLEL, Requirements::Timestamped), + ["Ok(Assessed(true))", "Ok(Assessed(true))"] + ); +} + +#[test] +fn a_countersignature_is_an_actor_of_the_root_b_lt() { + // The counter signer's own path and status belong to the root's census. + assert_eq!( + every_signature(B_LT_COUNTERSIGNED, Requirements::LongTerm)[0], + "Ok(Assessed(true))" + ); +} + +#[test] +fn a_responder_named_by_key_hash_is_authenticated() { + // RFC 6960 §4.2.1 fixes SHA-1 for this identity; the default policy applies. + assert_eq!( + every_signature(B_LT_BY_KEY, Requirements::LongTerm), + ["Ok(Assessed(true))"] + ); +} + +#[test] +fn a_later_archive_covers_the_earlier_one() { + assert_eq!( + every_signature(B_LTA_RENEWED, Requirements::Archival), + ["Ok(Assessed(true))"] + ); +} + +#[test] +fn every_work_ceiling_refuses_without_a_partial_level() { + // Scanning the ceilings through every stage: below what the document needs + // a refusal surfaces as a typed error, never as a panic or a met level + // assembled from a partial census. + let mut met = false; + let mut work = 1 << 12; + while work <= 1 << 28 { + let result = level_in( + B_LTA, + Requirements::Archival, + &Given { + anchors: &[ROOT], + ..Given::default() + }, + (AMPLE.0, work), + all_met, + ); + match result { + Ok(Ok(Outcome::Assessed(true))) => met = true, + Ok(Ok(other)) => panic!("resource refusal became a fact: {other:?}"), + Ok(Err(_)) | Err(_) => assert!(!met, "a larger ceiling failed at {work}"), + } + work += work / 3; + } + assert!(met, "the largest ceiling completes"); +} + +#[test] +fn every_storage_ceiling_refuses_without_a_partial_level() { + // The same scan over retained storage: allocation refusal is an error at + // every stage, never a met level or a negative fact. + let mut met = false; + let mut memory = 1 << 10; + while memory <= AMPLE.0 { + let result = level_in( + B_LTA, + Requirements::Archival, + &Given { + anchors: &[ROOT], + ..Given::default() + }, + (memory, AMPLE.1), + all_met, + ); + match result { + Ok(Ok(Outcome::Assessed(true))) => met = true, + Ok(Ok(other)) => panic!("resource refusal became a fact: {other:?}"), + Ok(Err(_)) | Err(_) => assert!(!met, "a larger ceiling failed at {memory}"), + } + memory += memory / 3; + } + assert!(met, "the largest ceiling completes"); +} + +#[test] +fn a_timestamp_without_a_trusted_authority_proves_nothing() { + // The token is mathematically valid and its root is a known certificate, + // but no supplied anchor ends its path. + let result = level(B_T, Requirements::Timestamped, &[], &[ROOT]); + assert!( + matches!( + result, + Ok(Outcome::Timestamp { + failure: TimestampFailure::Path(_), + .. + }) + ), + "{result:?}" + ); +} diff --git a/docs/features.md b/docs/features.md index 803404c5..9d4904a0 100644 --- a/docs/features.md +++ b/docs/features.md @@ -30,12 +30,6 @@ RustCrypto is bundled with the signature graph, not a separate Cargo feature named `rustcrypto`. Compiling an optional provider does not remove RustCrypto key/container codecs and does not make the whole build FIPS approved. There is no ordinary AWS-LC adapter and no missing-operation fallback between providers. -The optional provider temporarily pins official `aws-lc-rs =1.18.2` and -`aws-lc-fips-sys =0.14.3`: the newer sys release's bindgen dependency can resolve -incompatible `syn`/`prettyplease` major versions. The direct optional sys -dependency constrains published consumer resolution only; no sys API is used. -This also defers newer AWS build/linking changes until a compatible update is -qualified; it is not a fork or an additional provider. `legacy-algorithms` alone does not enable XMLDSig or XMLEnc. Canonicalization helpers remain available with an XML backend even without the `c14n` marker. `no-unsafe` and `embedded` are compatibility markers, not separate security modes. diff --git a/interop/xades/README.md b/interop/xades/README.md index 063a1f18..7338c4c4 100644 --- a/interop/xades/README.md +++ b/interop/xades/README.md @@ -64,7 +64,13 @@ There is no Rust self-sign/self-verify evidence in this package. | DSS signing-certificate digest check in ISC | failed | A matching root digest is counted despite no reference to the selected signer; see the focused investigation | | DSS missing Type classification | verified | DSS reports XAdES-BES rather than Baseline-B; Rust refuses SignedProperties binding | | Full XAdES/trust verdict from DSS | failed | All nine global outcomes are INDETERMINATE / CERTIFICATE_CHAIN_GENERAL_FAILURE; no revocation data was supplied | -| B-T/B-LT/B-LTA, TSA/OCSP/CRL, EU Trusted Lists, legal qualification | not run or blocked | Outside this corpus; no such evidence or trust service inputs | +| B-T/B-LT/B-LTA over a test PKI (`crates/xml-sec-xades/tests/fixtures/levels`) | verified | OpenSSL issues every token, CRL and OCSP response; `xades levels` compares DSS's format and indication on each fixture, `validate` reaches the same levels, detached, parallel and countersigned structures included | +| RFC 3161 token without stated accuracy | verified | Rejected unless `Inputs::accuracies` states the accuracy of its authority and signed policy (RFC 3161 §2.4.2); a token's own field comes first | +| Signatures produced by DSS 6.5.1 | verified | `xades levels` reads them at the DSS tag at run time, outside the repository: `xades-lta-valid` meets B-T and copied tokens are rejected. Its last archive TSA has no status in the document, so B-LT and B-LTA stop at `NoSource` (EN 319 132-1 §6.3(x)). `xades-t-with-tsvd` carries an unsorted certificate SET OF: `TokenProfile::Etsi` refuses it because an unmarked token is DER (§5.1.3), `TokenProfile::Cms` reads it as RFC 5652 BER | +| OCSP responder outside the issuer | verified | Counts only as `Inputs::responders` configures it for that issuer (RFC 6960 §4.2.2.2) | +| `RenewedDigestsV2` over a signed Manifest | verified | B-LTA with SHA-512 renewal of a SHA-256 Manifest reference; a wrong new digest or reference digest stops the level with `Outcome::Renewal` (EN 319 132-1 §5.5.3). No independent validator checked it | +| Caller-supplied CRLs and OCSP responses | verified | They answer status but do not count as incorporated, so the level stays unmet | +| EU Trusted Lists, legal qualification | not run or blocked | Outside this corpus; no such trust service inputs | | AL/SignedXml pipeline or direct Rust invocation from AL/SaaS | not run or blocked | No Business Central environment; no deployment assumption | Only the 100 independent libxmlsec1 `expected-reference-N.bin` and @@ -98,7 +104,8 @@ XMLSEC1_BIN=/path/to/native/xmlsec1 cargo run -p xml-sec-tools -- xades check -- This is the same entry point used by the required `XAdES interoperability corpus` CI job. It runs harness regressions, every retained signed fixture, both explicit here modes, -authenticated replay, all independent octet vectors and default/strict DSS expectations. +authenticated replay, all independent octet vectors, default/strict DSS expectations and +DSS's verdict on the baseline-level fixtures. No part may skip on a missing oracle. The existing aggregate `test` job requires its success. CI publishes actual octets, hashes, first-difference diagnostics and full DSS reports as `xades-interop-results` run artifacts. It never updates fixtures or expectations. @@ -161,9 +168,9 @@ cargo check -p xml-sec-xml-input --no-default-features --target thumbv7em-none-e cargo clean ``` -Core XMLDSig and the current XAdES adapter require std; passing XML-input alloc checks -does not establish alloc-only XMLDSig/XAdES support. No production dependency or policy -surface was changed. Probe memory/work ceilings are test execution accounts. +The XAdES adapter builds without std; CI lints it on a bare-metal target and +`wasm-smoke` executes B-LTA validation in the compiled module. Probe memory/work +ceilings are test execution accounts. Generated `.tar.gz` bundles remain local artifacts; Git contains the reviewable sources, selected fixtures, independent expected bytes, expected conclusions and provenance. The full workspace CLI suite requires native libxmlsec1 1.3.13 and the pinned @@ -232,8 +239,8 @@ certificate engine, C14N, transform or XAdES implementation. Existing work was i existing boundaries; this corpus does not close them. No duplicate backlog was created. Trust in this package means only the explicitly supplied -synthetic root at the fixed test instant. No revocation, reliable signing time or legal -qualification follows from that path or from `all_root_requirements_met()`. +synthetic root at the fixed test instant. No legal qualification follows from that path +or from `all_root_requirements_met()`. ## Intended collaboration diff --git a/interop/xades/SHA256SUMS b/interop/xades/SHA256SUMS index 3b0d30b2..8b9fee30 100644 --- a/interop/xades/SHA256SUMS +++ b/interop/xades/SHA256SUMS @@ -1,10 +1,11 @@ e6cc48410ec8597478dae1df8bda75fe5323a818c3f8f4261a927630f8b468a3 interop/xades/.gitattributes c949c65b59cd74cc712fab76947b07d015627f40cf96d90eb28da66ff1f45000 interop/xades/COMMENT-DRAFT.md c56a60f65166e58b42851a11a9b25d2c4de9ee45217cc1e1925c01501fa8f08d interop/xades/PROVENANCE.md -ea53e843bd7a17b1ffcfa766d38c3ab8e135b18240978ba9bf0084c90a6ebfad interop/xades/README.md +0838032bc4bdd7cb5545bdff670924b7495a1de61c4d27801cb30a5197868d66 interop/xades/README.md 3dbdfc423c8c35aaa62ef121e3c3fc18e7d83fa5b027805db50fab8907257985 interop/xades/cases.json -ef9fa95e1b55115dc33f9851a064e37302f4c072322175702a42ae97e8fd23f3 interop/xades/dss/pom.xml +a7884394d334880f0a071bfd4b6a19aba70af84fe84075eb4b90a9ee9894f25e interop/xades/dss/pom.xml 569e9381ef81ea2db35192e3be9cc81dfd87b6c8104c25f09d4c18f7311957bf interop/xades/dss/src/main/java/BindingProbe.java +3f697b17609b7ff35ad5683721f4e97d68ac68f8d9cbdc2148a66ac3b4358bb3 interop/xades/dss/src/main/java/LevelProbe.java f05a8c8f25214bd2d72b2ab96a3dff48450b26f77d07bfad3104bfedbdf756ff interop/xades/dss/src/main/java/Probe.java fa7183cebc29aeccebf0172e74ad327d736d12b66ff8c8aac41fa96851894caa interop/xades/dss-evidence/expectations.json 9d057b9213d8275fd36ccad8cf48c9053dde729f038af6a8c3611ed72d2691e4 interop/xades/dss-investigation/README.md diff --git a/interop/xades/dss/pom.xml b/interop/xades/dss/pom.xml index d8299e71..4bcbeb39 100644 --- a/interop/xades/dss/pom.xml +++ b/interop/xades/dss/pom.xml @@ -7,6 +7,7 @@ eu.europa.ec.joinup.sd-dssdss-validation6.5.1 eu.europa.ec.joinup.sd-dssdss-policy-jaxb6.5.1 eu.europa.ec.joinup.sd-dssdss-utils-apache-commons6.5.1 + eu.europa.ec.joinup.sd-dssdss-crl-parser-x509crl6.5.1 ${project.basedir}/../../../target/xades-dss org.apache.maven.pluginsmaven-compiler-plugin3.14.1 diff --git a/interop/xades/dss/src/main/java/LevelProbe.java b/interop/xades/dss/src/main/java/LevelProbe.java new file mode 100644 index 00000000..9f518c1c --- /dev/null +++ b/interop/xades/dss/src/main/java/LevelProbe.java @@ -0,0 +1,52 @@ +import java.nio.file.*; +import java.time.Instant; +import java.util.Date; +import eu.europa.esig.dss.enumerations.ValidationLevel; +import eu.europa.esig.dss.model.FileDocument; +import eu.europa.esig.dss.spi.DSSUtils; +import eu.europa.esig.dss.spi.validation.CommonCertificateVerifier; +import eu.europa.esig.dss.spi.x509.CommonTrustedCertificateSource; +import eu.europa.esig.dss.validation.SignedDocumentValidator; + +/** + * Independent long-term validation of one signature. Only the supplied anchor + * is trusted, nothing is fetched: every status comes from the document itself. + * Arguments: document, anchor DER, validation time in Unix seconds, output, + * and the detached content its reference names, if any. + */ +public class LevelProbe { + public static void main(String[] args) throws Exception { + var verifier = new CommonCertificateVerifier(); + verifier.setAIASource(null); + verifier.setOcspSource(null); + verifier.setCrlSource(null); + var anchors = new CommonTrustedCertificateSource(); + anchors.addCertificate(DSSUtils.loadCertificate(Files.readAllBytes(Path.of(args[1])))); + verifier.setTrustedCertSources(anchors); + var validator = SignedDocumentValidator.fromDocument(new FileDocument(args[0])); + validator.setCertificateVerifier(verifier); + if (args.length > 4) { + var content = new FileDocument(args[4]); + content.setName(Path.of(args[4]).getFileName().toString()); + validator.setDetachedContents(java.util.List.of(content)); + } + validator.setValidationTime(Date.from(Instant.ofEpochSecond(Long.parseLong(args[2])))); + validator.setValidationLevel(ValidationLevel.ARCHIVAL_DATA); + var reports = validator.validateDocument(); + Path output = Path.of(args[3]); + Files.createDirectories(output); + Files.writeString(output.resolve("diagnostic.xml"), reports.getXmlDiagnosticData()); + Files.writeString(output.resolve("detailed.xml"), reports.getXmlDetailedReport()); + Files.writeString(output.resolve("simple.xml"), reports.getXmlSimpleReport()); + var simple = reports.getSimpleReport(); + for (var id : simple.getSignatureIdList()) { + System.out.printf( + "%s format=%s indication=%s subindication=%s errors=%s%n", + id, + simple.getSignatureFormat(id), + simple.getIndication(id), + simple.getSubIndication(id), + simple.getAdESValidationErrors(id).stream().map(message -> message.getValue()).toList()); + } + } +} diff --git a/src/xmldsig/extension/tree.rs b/src/xmldsig/extension/tree.rs index dff07a43..b2676795 100644 --- a/src/xmldsig/extension/tree.rs +++ b/src/xmldsig/extension/tree.rs @@ -5,7 +5,7 @@ //! authenticates the node it reads. use crate::document::{DocumentView, NodeIdentity, XmlDocumentError}; -use structured_asn1::memory::{MemoryError, Work}; +use structured_asn1::memory::{MemoryError, OwnedVec, Work}; /// Original tree read failure, independent of the content it would have read. #[derive(Debug, thiserror::Error)] @@ -153,6 +153,28 @@ pub fn with_base64( work: &W, visitor: impl for<'a> FnOnce(&'a [u8]) -> R, ) -> Result { + Ok(visitor(&decode_base64(view, owner, work)?)) +} + +/// The same decoding into independently retained storage, charged to `work` +/// for as long as the returned bytes live. +/// +/// # Errors +/// +/// The errors of [`with_base64`]. +pub fn base64_owned( + view: DocumentView<'_>, + owner: NodeIdentity, + work: &W, +) -> Result, TreeError> { + Ok(decode_base64(view, owner, work)?.into_owned()) +} + +fn decode_base64( + view: DocumentView<'_>, + owner: NodeIdentity, + work: &W, +) -> Result, TreeError> { // Zero-fill source for initialized decode storage, in bounded chunks. const ZEROS: [u8; 512] = [0; 512]; charge(work, 1)?; @@ -195,5 +217,5 @@ pub fn with_base64( payload .decode_into(&mut decoded) .map_err(TreeError::Base64)?; - Ok(visitor(&decoded)) + Ok(decoded) } diff --git a/src/xmldsig/pkix.rs b/src/xmldsig/pkix.rs index c5d7d557..9ae61957 100644 --- a/src/xmldsig/pkix.rs +++ b/src/xmldsig/pkix.rs @@ -1065,7 +1065,7 @@ pub(crate) fn effective_target_spki( /// Certificate signatures use the same selected engine and permissions as CRLs. #[derive(Clone, Copy)] -pub(crate) struct ProviderVerifier<'a> { +pub struct ProviderVerifier<'a> { pub(crate) provider: &'a dyn crate::provider::CryptoProvider, pub(crate) allowed: Option<&'a crate::policy::CertificateSignatureAlgorithms>, } diff --git a/src/xmldsig/verify/session.rs b/src/xmldsig/verify/session.rs index bcc849bd..7e646c1f 100644 --- a/src/xmldsig/verify/session.rs +++ b/src/xmldsig/verify/session.rs @@ -15,6 +15,7 @@ use structured_asn1::memory::{MemoryError, OwnedMap, OwnedText, OwnedVec, Work}; mod detached; pub use detached::*; +mod element; mod hash_uses; pub use hash_uses::*; mod key_info; @@ -1100,35 +1101,6 @@ impl SelectedSignature<'_, '_, '_, '_, W, Q> { Ok(allowed) } - /// The timestamp's canonicalization method, after its URI passes the - /// operation's transform permission. - fn replay_timestamp_method( - &self, - method: NodeIdentity, - allowed: Option<&BTreeSet>, - ) -> Result<(crate::c14n::C14nAlgorithm, Option<&str>), ReplayError> { - let processing = ReplayError::Processing; - let method = self - .session - .view - .resolve_node(method) - .map_err(|error| processing(error.into()))?; - let uri = method.attribute("Algorithm").ok_or_else(|| { - processing(DsigError::InvalidStructure { - reason: "timestamp method has no Algorithm", - }) - })?; - self.work - .charge_work(uri.len() as u64) - .map_err(|error| processing(error.into()))?; - enforce_current_transform_allowed(allowed, uri, self.work).map_err(processing)?; - super::super::parse::parse_replay_canonicalization_method( - method, - &crate::c14n::scratch::Accounted(self.work), - ) - .map_err(replay_parse_failure) - } - fn replay_instruction( &self, descriptor: &AuthenticatedReference<'_>, @@ -1170,7 +1142,9 @@ impl SelectedSignature<'_, '_, '_, '_, W, Q> { } let timestamp = match mode { ReplayMode::ReferenceOutput => None, - ReplayMode::Timestamp(method) => Some(self.replay_timestamp_method(method, allowed)?), + ReplayMode::Timestamp(method) => { + Some(self.session.timestamp_method(method, allowed, self.work)?) + } }; let budget = &self.session.budgets.transforms; let Some(data) = self.session.resolver.replay_input_from_with_budget( diff --git a/src/xmldsig/verify/session/element.rs b/src/xmldsig/verify/session/element.rs new file mode 100644 index 00000000..aeda98b6 --- /dev/null +++ b/src/xmldsig/verify/session/element.rs @@ -0,0 +1,95 @@ +//! Canonical output of one original element under an original method node. + +use super::{ + BTreeSet, DsigError, NodeIdentity, ReplayError, ReplayWriter, String, VerifiedSession, Work, + enforce_current_transform_allowed, replay_parse_failure, +}; + +impl VerifiedSession<'_, '_, '_, W> { + /// The timestamp's canonicalization method, after its URI passes the + /// operation's transform permission. + pub(super) fn timestamp_method( + &self, + method: NodeIdentity, + allowed: Option<&BTreeSet>, + work: &Q, + ) -> Result<(crate::c14n::C14nAlgorithm, Option<&str>), ReplayError> { + let processing = ReplayError::Processing; + let method = self + .view + .resolve_node(method) + .map_err(|error| processing(error.into()))?; + let uri = method.attribute("Algorithm").ok_or_else(|| { + processing(DsigError::InvalidStructure { + reason: "timestamp method has no Algorithm", + }) + })?; + work.charge_work(uri.len() as u64) + .map_err(|error| processing(error.into()))?; + enforce_current_transform_allowed(allowed, uri, work).map_err(processing)?; + super::super::super::parse::parse_replay_canonicalization_method( + method, + &crate::c14n::scratch::Accounted(work), + ) + .map_err(replay_parse_failure) + } + + /// Stream the canonical form of `element`'s whole subtree under the original + /// `CanonicalizationMethod` node `method`, including its parameters. Ancestor + /// namespace and `xml:*` context is the C14N algorithm's own. Output and + /// scratch spend `work`; the operation's transform policy and cumulative + /// C14N allowance still apply. This reads the node unauthenticated: the + /// caller establishes why the element belongs to its input. + /// + /// # Errors + /// Returns a processing error for a foreign/stale identity, a non-element + /// `element`, an invalid or forbidden method, or resource refusal. Preserves + /// receiver errors separately. + pub fn canonicalize_element( + &self, + element: NodeIdentity, + method: NodeIdentity, + work: &Q, + receiver: &mut impl FnMut(&[u8]) -> Result<(), E>, + ) -> Result<(), ReplayError> { + let processing = ReplayError::Processing; + work.charge_work(1) + .map_err(|error| processing(error.into()))?; + let allowed = self.context.policy.transforms.allowed_algorithms.as_ref(); + let (algorithm, prefixes) = self.timestamp_method(method, allowed, work)?; + let node = self + .view + .resolve_node(element) + .map_err(|error| processing(error.into()))?; + if !node.is_element() { + return Err(processing(DsigError::InvalidRequest { + reason: "canonicalization input is not an element", + })); + } + let budget = &self.budgets.transforms; + let mut output = ReplayWriter { + work, + budget, + canonicalizing: true, + receiver, + failure: None, + }; + let result = crate::c14n::canonicalize_visible_to_writer_accounted( + node.document(), + Some(&crate::c14n::SubtreeVisibility { apex: node }), + &algorithm, + super::super::super::transforms::replay_output_limit(budget), + budget.xml_base_resolution(), + &mut output, + work, + prefixes, + ); + if let Some(error) = output.failure { + return Err(error); + } + result.map_err(|error| match error { + crate::c14n::C14nError::SharedExecution(error) => ReplayError::Processing(error.into()), + error => super::super::super::transforms::replay_c14n_error(error, budget).into(), + }) + } +} diff --git a/src/xmldsig/verify/session/lookup.rs b/src/xmldsig/verify/session/lookup.rs index 6aad91ae..35f1759d 100644 --- a/src/xmldsig/verify/session/lookup.rs +++ b/src/xmldsig/verify/session/lookup.rs @@ -208,6 +208,21 @@ impl VerifiedSession<'_, '_, '_, W> { super::super::super::pkix::path_bounds(self.context.policy.key_trust.max_x509_chain_depth) } + /// CRL and OCSP signature checks through this operation's provider and + /// certificate-signature permissions. Any key it is given is checked as + /// supplied: the caller establishes that key's authority. + pub fn revocation_verifier(&self) -> super::super::super::pkix::ProviderVerifier<'_> { + super::super::super::pkix::ProviderVerifier { + provider: self.context.provider, + allowed: self + .context + .policy + .key_trust + .certificate_signature_algorithms + .as_ref(), + } + } + /// Certificate-path signature checks for `chain` and `anchor` through this /// operation's provider and certificate trust policy. Issuer key material /// is read on a fresh account bounded by this operation's X.509 resource diff --git a/tests/cms_timestamp.rs b/tests/cms_timestamp.rs index 0460d1d4..e403d9be 100644 --- a/tests/cms_timestamp.rs +++ b/tests/cms_timestamp.rs @@ -133,6 +133,7 @@ fn check( utc: &utc, reference: Some(Instant::new(1_800_000_000, 0).expect("instant")), window: None, + policy_accuracy: None, }; match token.check(&cms, &parent, &context, &mut [covered], |_, _| { Ok::<_, ()>(false) diff --git a/tests/wasm-smoke/Cargo.toml b/tests/wasm-smoke/Cargo.toml index e70616b0..a172c566 100644 --- a/tests/wasm-smoke/Cargo.toml +++ b/tests/wasm-smoke/Cargo.toml @@ -11,6 +11,7 @@ crate-type = ["cdylib"] [dependencies] xml-sec = { path = "../..", default-features = false, features = ["c14n", "cms", "xml-backend-roxmltree"] } -structured-asn1 = { version = "0.18.0", default-features = false, features = ["alloc"] } -structured-cms = { version = "0.18.0", default-features = false, features = ["alloc"] } -structured-pkix = { version = "0.18.0", default-features = false, features = ["alloc"] } +xml-sec-xades = { path = "../../crates/xml-sec-xades", default-features = false, features = ["xml-backend-roxmltree"] } +structured-asn1 = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-cms = { version = "0.20.0", default-features = false, features = ["alloc"] } +structured-pkix = { version = "0.20.0", default-features = false, features = ["alloc"] } diff --git a/tests/wasm-smoke/src/lib.rs b/tests/wasm-smoke/src/lib.rs index 75907468..3baf741c 100644 --- a/tests/wasm-smoke/src/lib.rs +++ b/tests/wasm-smoke/src/lib.rs @@ -10,11 +10,16 @@ use structured_cms::timestamp::{CheckContext, ImprintAgreement, Token, TokenSign use structured_pkix::Certificate; use structured_pkix::path::WorkingKey; use structured_pkix::temporal::{Instant, LeapTable}; +use xml_sec::XmlDocument; use xml_sec::c14n::{C14nAlgorithm, C14nMode, canonicalize_xml}; use xml_sec::policy::{CertificateSignatureAlgorithms, VerificationPolicy}; use xml_sec::provider::RustCryptoProvider; use xml_sec::xmldsig::cms::CmsProvider; -use xml_sec::xmldsig::{DsigStatus, FailureReason, verify_signature_with_pem_key}; +use xml_sec::xmldsig::{ + DefaultKeyResolver, DsigStatus, FailureReason, KeyResolverConfig, VerificationRequest, + VerifyContext, verify_signature_with_pem_key, with_verified_request, +}; +use xml_sec_xades::{Inputs, Outcome, Requirements, TokenProfile, validate}; /// A donor SAML 2.0 response signed by its identity provider. const SIGNED_RESPONSE: &str = include_str!("../../fixtures/saml/response_signed_by_idp_ecdsa.xml"); @@ -23,6 +28,11 @@ const SIGNER_KEY: &str = include_str!("../../fixtures/keys/ec/saml-idp-ecdsa-pub const TOKEN: &[u8] = include_bytes!("../../fixtures/cms/timestamp/ed25519.tst"); const TOKEN_CERTIFICATE: &[u8] = include_bytes!("../../fixtures/cms/timestamp/ed25519.der"); const TOKEN_PAYLOAD: &[u8] = include_bytes!("../../fixtures/cms/timestamp/payload.txt"); +/// A B-LTA signature whose tokens and status OpenSSL produced. +const LEVELS_ARCHIVAL: &str = + include_str!("../../../crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml"); +const LEVELS_ROOT: &[u8] = + include_bytes!("../../../crates/xml-sec-xades/tests/fixtures/levels/root.der"); /// Called in the compiled WASM module, not a native substitute. #[unsafe(no_mangle)] @@ -52,6 +62,68 @@ pub extern "C" fn xml_sec_wasm_verify() -> u32 { u32::from(valid && rejected) } +/// Whether the archival level of `xml`'s first signature is met, in this module. +fn archival_level(xml: &str) -> Option { + let resolver = DefaultKeyResolver::new(KeyResolverConfig { + trusted_certs: vec![LEVELS_ROOT.to_vec()], + ..KeyResolverConfig::default() + }); + let mut policy = VerificationPolicy::default(); + policy.key_trust.verify_x509_chains = true; + policy.key_trust.verification_time = Some(Instant::new(1_800_000_000, 0)?); + let context = VerifyContext::new().policy(policy).key_resolver(&resolver); + let document = XmlDocument::parse(xml).ok()?; + let request = VerificationRequest::default(); + let account = Memory::new(Arc::new(MemoryAccount::new(1 << 25, 1 << 31))); + let utc = LeapTable::new(0, 2_000_000_000, &[]).ok()?; + let anchors: &[&[u8]] = &[LEVELS_ROOT]; + with_verified_request(&document, &context, &request, &account, |session| { + let inputs = Inputs { + requirements: Requirements::Archival, + token_profile: TokenProfile::Etsi, + anchors, + certificates: &[], + utc: &utc, + accuracies: &[], + responders: &[], + crls: &[], + responses: &[], + }; + let signature = session.evidence().signatures()[0].identity(); + Ok(validate(&session, signature, &inputs, |level| { + level.all_requirements_met() + })) + }) + .ok()? + .ok() + .and_then(|outcome| match outcome { + Outcome::Assessed(met) => Some(met), + _ => None, + }) +} + +/// B-LTA validation in the compiled WASM module: real tokens, CRLs and OCSP +/// meet the level, and a changed archive token does not. +#[unsafe(no_mangle)] +pub extern "C" fn xml_sec_wasm_xades() -> u32 { + let open = ""; + let Some((start, _)) = LEVELS_ARCHIVAL.rmatch_indices(open).next() else { + return 0; + }; + let at = start + open.len() + 400; + let replacement = if &LEVELS_ARCHIVAL[at..=at] == "A" { + "B" + } else { + "A" + }; + let tampered = format!( + "{}{replacement}{}", + &LEVELS_ARCHIVAL[..at], + &LEVELS_ARCHIVAL[at + 1..] + ); + u32::from(archival_level(LEVELS_ARCHIVAL) == Some(true) && archival_level(&tampered).is_none()) +} + /// The signature answer for `token`, if its check completed with a matching /// imprint and, for a valid signature, retained evidence. fn check_token(token: &[u8]) -> Option { @@ -76,6 +148,7 @@ fn check_token(token: &[u8]) -> Option { utc: &utc, reference: Some(Instant::new(1_800_000_000, 0)?), window: None, + policy_accuracy: None, }; let checked = token .check(&cms, &parent, &context, &mut [TOKEN_PAYLOAD], |_, _| { diff --git a/tools/xml-sec-tools/src/wasm_smoke.rs b/tools/xml-sec-tools/src/wasm_smoke.rs index 5525bf45..481d0117 100644 --- a/tools/xml-sec-tools/src/wasm_smoke.rs +++ b/tools/xml-sec-tools/src/wasm_smoke.rs @@ -10,7 +10,7 @@ mod tests; /// Each export, the failure it reports when it does not return 1, and the /// line printed when it does. -const EXPORTS: [(&str, &str, &str); 3] = [ +const EXPORTS: [(&str, &str, &str); 4] = [ ( "xml_sec_wasm_smoke", "WASM canonicalization must produce exact expected bytes", @@ -26,6 +26,11 @@ const EXPORTS: [(&str, &str, &str); 3] = [ "WASM CMS timestamp check must accept the token and reject tampering", "WASM CMS timestamp check passed", ), + ( + "xml_sec_wasm_xades", + "WASM XAdES B-LTA must accept the signature and refuse a changed archive token", + "WASM XAdES B-LTA passed", + ), ]; /// The build of the smoke consumer for `wasm32-unknown-unknown`. diff --git a/tools/xml-sec-tools/src/wasm_smoke/tests.rs b/tools/xml-sec-tools/src/wasm_smoke/tests.rs index 7281ad1d..c179d09b 100644 --- a/tools/xml-sec-tools/src/wasm_smoke/tests.rs +++ b/tools/xml-sec-tools/src/wasm_smoke/tests.rs @@ -25,15 +25,16 @@ fn module(exports: &[(&str, u8)]) -> Vec { bytes } -const ALL: [&str; 3] = [ +const ALL: [&str; 4] = [ "xml_sec_wasm_smoke", "xml_sec_wasm_verify", "xml_sec_wasm_cms", + "xml_sec_wasm_xades", ]; /// A module where the export at `failing`, if any, reports failure. fn answering(failing: Option) -> Vec { - let exports = [0, 1, 2].map(|index| (ALL[index], u8::from(Some(index) != failing))); + let exports = [0, 1, 2, 3].map(|index| (ALL[index], u8::from(Some(index) != failing))); module(&exports) } @@ -41,9 +42,14 @@ fn answering(failing: Option) -> Vec { fn every_compiled_export_must_report_success() { // The check is each export's own answer, not that the module loaded. assert!(check_module(&answering(None)).is_ok()); - for (index, failure) in ["canonicalization", "XMLDSig verification", "CMS timestamp"] - .into_iter() - .enumerate() + for (index, failure) in [ + "canonicalization", + "XMLDSig verification", + "CMS timestamp", + "XAdES B-LTA", + ] + .into_iter() + .enumerate() { let error = check_module(&answering(Some(index))).unwrap_err(); assert!(error.contains(failure), "{error}"); diff --git a/tools/xml-sec-tools/src/xades/check.rs b/tools/xml-sec-tools/src/xades/check.rs index a0a782c2..b7e5405b 100644 --- a/tools/xml-sec-tools/src/xades/check.rs +++ b/tools/xml-sec-tools/src/xades/check.rs @@ -181,8 +181,9 @@ fn execute(corpus: &Corpus, output: &Path) -> Result<(), String> { &package.join("dss-investigation/strict-policy-expectations.json"), &binding.join("strict-policy-summary.json"), )?; + super::levels::execute(corpus, &output.join("levels"))?; println!( - "verified: live XMLDSig/XAdES, {count} independent octet vectors, DSS and strict-policy expectations" + "verified: live XMLDSig/XAdES, {count} independent octet vectors, DSS, strict-policy and baseline-level expectations" ); Ok(()) } diff --git a/tools/xml-sec-tools/src/xades/corpus.rs b/tools/xml-sec-tools/src/xades/corpus.rs index 09febbde..b10fa2da 100644 --- a/tools/xml-sec-tools/src/xades/corpus.rs +++ b/tools/xml-sec-tools/src/xades/corpus.rs @@ -144,6 +144,7 @@ fn template(corpus: &Corpus, fixtures: &Path, work: &Path) -> Result Result<(), String> { .map_err(|error| format!("unpack Maven: {error}")) } -/// Builds the probe and validates every case with DSS. -pub(crate) fn execute(corpus: &Corpus, logs: &Path) -> Result<(), String> { - if logs.exists() { - return Err("results already exist; select a fresh --results directory".into()); - } +/// Builds the probes against DSS, bootstrapping the pinned Maven once. +pub(crate) fn build(corpus: &Corpus, logs: &Path) -> Result<(), String> { let tools = tools(corpus); std::fs::create_dir_all(&tools).map_err(|error| error.to_string())?; std::fs::create_dir_all(logs).map_err(|error| error.to_string())?; @@ -228,6 +225,16 @@ pub(crate) fn execute(corpus: &Corpus, logs: &Path) -> Result<(), String> { &format!("-DoutputFile={}", logs.join("dependencies.json").display()), ])); corpus.require(&maven, &logs.join("dependencies"))?; + Ok(()) +} + +/// Builds the probe and validates every case with DSS. +pub(crate) fn execute(corpus: &Corpus, logs: &Path) -> Result<(), String> { + if logs.exists() { + return Err("results already exist; select a fresh --results directory".into()); + } + build(corpus, logs)?; + let package = corpus.package(); let cases: Value = serde_json::from_str(&xml::read(&package.join("cases.json"))?) .map_err(|error| error.to_string())?; let classpath = classpath(corpus)?; diff --git a/tools/xml-sec-tools/src/xades/fixtures.rs b/tools/xml-sec-tools/src/xades/fixtures.rs index e18aca54..8efeeb68 100644 --- a/tools/xml-sec-tools/src/xades/fixtures.rs +++ b/tools/xml-sec-tools/src/xades/fixtures.rs @@ -15,7 +15,7 @@ use std::process::{Command, Stdio}; #[cfg(test)] mod tests; -const SIGNED_PROPERTIES: &str = "http://uri.etsi.org/01903#SignedProperties"; +pub(crate) const SIGNED_PROPERTIES: &str = "http://uri.etsi.org/01903#SignedProperties"; const SHA256: &str = "http://www.w3.org/2001/04/xmlenc#sha256"; const SHA384: &str = "http://www.w3.org/2001/04/xmldsig-more#sha384"; const MD5: &str = "http://www.w3.org/2001/04/xmldsig-more#md5"; @@ -61,6 +61,8 @@ pub(crate) struct Signature<'a> { pub(crate) target: &'a str, pub(crate) reference_type: &'a str, pub(crate) objects: String, + /// `DataObjectFormat` properties of further signed data objects. + pub(crate) formats: String, pub(crate) x509: &'a str, pub(crate) unsigned: String, } @@ -80,6 +82,7 @@ impl Signature<'_> { target, reference_type, objects, + formats, x509, unsigned, } = self; @@ -116,7 +119,7 @@ impl Signature<'_> { {mime} - + {formats} {unsigned} @@ -224,6 +227,8 @@ pub(crate) struct Generator { pub(crate) xmlsec: OsString, pub(crate) work: PathBuf, pub(crate) output: PathBuf, + /// Repeated payload elements of the level fixtures, for size measurements. + pub(crate) units: usize, } /// Fails unless `command` succeeds; its diagnostics stay on stderr. @@ -239,7 +244,7 @@ fn succeed(mut command: Command, what: &str) -> Result<(), String> { } impl Generator { - fn openssl(&self, args: &[&str]) -> Result<(), String> { + pub(crate) fn openssl(&self, args: &[&str]) -> Result<(), String> { let mut command = Command::new("openssl"); command .args(args) @@ -314,7 +319,7 @@ impl Generator { } /// The DER encoding of `name.pem`. - fn der(&self, name: &str) -> Result, String> { + pub(crate) fn der(&self, name: &str) -> Result, String> { let output = Command::new("openssl") .args(["x509", "-in", &format!("{name}.pem"), "-outform", "DER"]) .current_dir(&self.work) @@ -346,7 +351,7 @@ impl Generator { Ok(output.stdout) } - fn digests(&self) -> Result { + pub(crate) fn digests(&self) -> Result { use sha2::Digest as _; let signer = self.der("signer")?; Ok(Digests { @@ -358,7 +363,13 @@ impl Generator { } /// Signs the node with ID `node` of `input` into `result` with xmlsec1. - fn sign(&self, input: &str, result: &Path, node: &str, key: &str) -> Result<(), String> { + pub(crate) fn sign( + &self, + input: &str, + result: &Path, + node: &str, + key: &str, + ) -> Result<(), String> { let mut command = Command::new(&self.xmlsec); command .args(["--sign", "--lax-key-search", "--privkey-pem", key]) @@ -403,6 +414,7 @@ pub(crate) fn baseline<'a>( target: "#sig", reference_type, objects: String::new(), + formats: String::new(), x509: "", unsigned: String::new(), } @@ -644,11 +656,24 @@ pub(crate) fn generate(generator: &Generator) -> Result<(), String> { } pub(crate) fn run(corpus: &super::Corpus, args: &[String]) -> Result<(), crate::repo::Failure> { - let usage = "usage: xades fixtures [--output DIR] [--work DIR]"; + let usage = "usage: xades fixtures [--levels] [--units N] [--output DIR] [--work DIR]"; let mut output = corpus.root.join("crates/xml-sec-xades/tests/fixtures"); let mut work = None; + let mut levels = false; + let mut units = 0; let mut args = args.iter(); while let Some(arg) = args.next() { + if arg == "--levels" { + levels = true; + continue; + } + if arg == "--units" { + units = args + .next() + .and_then(|value| value.parse().ok()) + .ok_or(usage)?; + continue; + } let value = super::absolute(args.next().ok_or(usage)?)?; match arg.as_str() { "--output" => output = value, @@ -659,9 +684,14 @@ pub(crate) fn run(corpus: &super::Corpus, args: &[String]) -> Result<(), crate:: // Without --work the keys and templates are removed with the scratch directory. let scratch = tempfile::tempdir().map_err(|error| error.to_string())?; let work = work.unwrap_or_else(|| scratch.path().to_owned()); - Ok(generate(&Generator { + let generator = Generator { xmlsec: corpus.xmlsec.clone(), work, output, - })?) + units, + }; + if levels { + return Ok(super::levels::generate(&generator)?); + } + Ok(generate(&generator)?) } diff --git a/tools/xml-sec-tools/src/xades/levels.rs b/tools/xml-sec-tools/src/xades/levels.rs new file mode 100644 index 00000000..d9780cab --- /dev/null +++ b/tools/xml-sec-tools/src/xades/levels.rs @@ -0,0 +1,956 @@ +//! `xades fixtures --levels`: B-T, B-LT and B-LTA signatures over a complete +//! test PKI. OpenSSL issues the certificates, CRLs, OCSP responses and RFC 3161 +//! tokens, libxml2 computes every timestamp input and xmlsec1 the XML +//! signature; xml-sec takes no part. Unsigned properties are added after +//! signing, as a real signature gains them over its life. + +use super::fixtures::{ + Digests, Generator, RSA_SHA256_PROFILE, Signature, TEST_INSTANT, baseline, counter_signature, + detached_reference, document, target_reference, +}; +use super::{DS, EXC, SP, write}; +use base64::Engine as _; +use base64::engine::general_purpose::STANDARD; +use sha2::{Digest as _, Sha256, Sha512}; +use std::process::{Command, Stdio}; + +const V141: &str = "http://uri.etsi.org/01903/v1.4.1#"; +const KEY: &str = "signer.key,signer.pem,issuer.pem"; + +/// Name, issuing CA, subject and extensions of each end of the PKI. +const CERTIFICATES: [(&str, &str, &str, &str); 5] = [ + ( + "issuer", + "root", + "/CN=xml-sec XAdES Levels Issuer", + "basicConstraints=critical,CA:TRUE,pathlen:0\nkeyUsage=critical,keyCertSign,cRLSign\nsubjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid\n", + ), + ( + "signer", + "issuer", + "/CN=xml-sec XAdES Levels Signer", + "basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature,nonRepudiation\nsubjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid\n", + ), + ( + "tsa", + "issuer", + "/CN=xml-sec XAdES Levels TSA", + "basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature\nextendedKeyUsage=critical,timeStamping\nsubjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid\n", + ), + ( + "responder", + "issuer", + "/CN=xml-sec XAdES Levels OCSP", + "basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature\nextendedKeyUsage=critical,OCSPSigning\nnoCheck=ignored\nsubjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid\n", + ), + // Not issued by the signer's CA, so only local configuration authorizes it. + ( + "outsider", + "root", + "/CN=xml-sec XAdES Levels Configured OCSP", + "basicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature\nextendedKeyUsage=critical,OCSPSigning\nsubjectKeyIdentifier=hash\nauthorityKeyIdentifier=keyid\n", + ), +]; + +const CA_CONFIG: &str = "[ca]\ndefault_ca=crl\n[crl]\ndatabase=NAME.index\ncrlnumber=NAME.crlnumber\ncertificate=NAME.pem\nprivate_key=NAME.key\ndefault_md=sha256\ndefault_crl_days=3650\ncrl_extensions=ext\n[ext]\nauthorityKeyIdentifier=keyid\n[delta]\nauthorityKeyIdentifier=keyid\n2.5.29.27=critical,DER:02:01:01\n"; + +const TSA_CONFIG: &str = "[tsa]\ndefault_tsa=levels\n[levels]\nserial=tsa.serial\ncrypto_device=builtin\nsigner_cert=tsa.pem\nsigner_key=tsa.key\nsigner_digest=sha256\ndefault_policy=1.3.6.1.4.1.13762.3\ndigests=sha256\naccuracy=secs:1\nclock_precision_digits=0\nordering=no\ntsa_name=no\ness_cert_id_chain=no\ness_cert_id_alg=sha256\n"; + +/// Runs `xmllint --exc-c14n` over `xml`, in `generator`'s scratch directory. +fn canonical(generator: &Generator, xml: &str) -> Result, String> { + let input = generator.work.join("c14n-input.xml"); + write(&input, xml)?; + let output = Command::new("xmllint") + .args(["--exc-c14n"]) + .arg(&input) + .stderr(Stdio::inherit()) + .output() + .map_err(|error| format!("xmllint: {error}"))?; + if !output.status.success() { + return Err("xmllint --exc-c14n failed".into()); + } + Ok(output.stdout) +} + +/// The element of `xml` starting at `open`, with the namespaces its ancestors +/// declared written on its own start tag: exclusive C14N renders only the ones +/// the element visibly uses, so unused declarations change nothing. +fn element(xml: &str, open: &str, close: &str) -> Result { + let start = xml + .find(open) + .ok_or_else(|| format!("{open} is not in the signature"))?; + let end = xml[start..] + .find(close) + .ok_or_else(|| format!("{close} is not in the signature"))? + + start + + close.len(); + let tag = start + open.len(); + Ok(format!( + r#"{} xmlns:ds="{DS}" xmlns:xades="{SP}" xmlns:xadesv141="{V141}"{}"#, + &xml[start..tag], + &xml[tag..end] + )) +} + +/// A signed document and its PKI in one scratch directory. +struct Levels<'a> { + generator: &'a Generator, +} + +impl Levels<'_> { + fn write(&self, name: &str, data: impl AsRef<[u8]>) -> Result<(), String> { + write(&self.generator.work.join(name), data) + } + + fn read(&self, name: &str) -> Result, String> { + super::read(&self.generator.work.join(name)) + } + + fn openssl(&self, args: &[&str]) -> Result<(), String> { + self.generator.openssl(args) + } + + fn issue(&self) -> Result<(), String> { + let validity = [ + "-not_before", + super::fixtures::NOT_BEFORE, + "-not_after", + super::fixtures::NOT_AFTER, + ]; + let mut root = vec![ + "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", "root.key", "-out", + "root.pem", + ]; + root.extend(validity); + root.extend([ + "-subj", + "/CN=xml-sec XAdES Levels Root", + "-addext", + "basicConstraints=critical,CA:TRUE", + "-addext", + "keyUsage=critical,keyCertSign,cRLSign", + ]); + self.openssl(&root)?; + for (name, issuer, subject, extensions) in CERTIFICATES { + let (key, request, file) = ( + format!("{name}.key"), + format!("{name}.csr"), + format!("{name}.ext"), + ); + self.openssl(&[ + "req", "-newkey", "rsa:2048", "-nodes", "-keyout", &key, "-out", &request, "-subj", + subject, + ])?; + self.write(&file, extensions)?; + let (ca, ca_key, certificate) = ( + format!("{issuer}.pem"), + format!("{issuer}.key"), + format!("{name}.pem"), + ); + let mut sign = vec![ + "x509", + "-req", + "-in", + &request, + "-CA", + &ca, + "-CAkey", + &ca_key, + "-out", + &certificate, + ]; + sign.extend(validity); + sign.extend(["-extfile", &file]); + self.openssl(&sign)?; + } + Ok(()) + } + + /// The hexadecimal serial number of `subject`'s certificate. + fn serial(&self, subject: &str) -> Result { + let certificate = format!("{subject}.pem"); + let serial = Command::new("openssl") + .args(["x509", "-in", &certificate, "-noout", "-serial"]) + .current_dir(&self.generator.work) + .output() + .map_err(|error| format!("openssl x509: {error}"))?; + let serial = String::from_utf8_lossy(&serial.stdout); + Ok(serial.trim().trim_start_matches("serial=").to_owned()) + } + + /// An empty complete CRL of `issuer`, as DER. + fn crl(&self, issuer: &str) -> Result, String> { + self.crl_listing(issuer, "") + } + + /// A complete CRL of `issuer` listing `subject` as revoked before the + /// fixtures' test instant, as DER. + fn crl_revoking(&self, issuer: &str, subject: &str) -> Result, String> { + let serial = self.serial(subject)?; + self.crl_listing( + issuer, + &format!("R\t450101000000Z\t261001000000Z\t{serial}\tunknown\t/CN={subject}\n"), + ) + } + + fn crl_listing(&self, issuer: &str, index: &str) -> Result, String> { + self.crl_numbered(issuer, index, "01\n", &[]) + } + + /// A delta over `issuer`'s complete CRL number 01 (RFC 5280 §5.2.4), naming + /// `subject` as revoked when there is one. + fn delta_crl(&self, issuer: &str, subject: Option<&str>) -> Result, String> { + let index = match subject { + Some(subject) => format!( + "R\t450101000000Z\t261001000000Z\t{}\tunknown\t/CN={subject}\n", + self.serial(subject)? + ), + None => String::new(), + }; + self.crl_numbered(issuer, &index, "02\n", &["-crlexts", "delta"]) + } + + fn crl_numbered( + &self, + issuer: &str, + index: &str, + number: &str, + extensions: &[&str], + ) -> Result, String> { + self.write(&format!("{issuer}.index"), index)?; + self.write(&format!("{issuer}.crlnumber"), number)?; + let config = format!("{issuer}.cnf"); + self.write(&config, CA_CONFIG.replace("NAME", issuer))?; + let (pem, der) = (format!("{issuer}.crl.pem"), format!("{issuer}.crl.der")); + let mut generate = vec!["ca", "-gencrl", "-config", &config, "-out", &pem]; + generate.extend(extensions); + self.openssl(&generate)?; + self.openssl(&["crl", "-in", &pem, "-outform", "DER", "-out", &der])?; + self.read(&der) + } + + /// A delegated OCSP response for `subject`, as a whole DER `OCSPResponse`, + /// naming its responder by key hash (RFC 6960 §4.2.1) when `by_key` is set. + fn ocsp(&self, subject: &str, by_key: bool) -> Result, String> { + self.ocsp_from("responder", subject, by_key) + } + + /// As [`Self::ocsp`], signed by `responder`. + fn ocsp_from(&self, responder: &str, subject: &str, by_key: bool) -> Result, String> { + let (signer, signer_key) = (format!("{responder}.pem"), format!("{responder}.key")); + let certificate = format!("{subject}.pem"); + let serial = self.serial(subject)?; + self.write( + "responder.index", + format!("V\t450101000000Z\t\t{serial}\tunknown\t/CN={subject}\n"), + )?; + self.write("responder.index.attr", "unique_subject = no\n")?; + let (request, response) = (format!("{subject}.ocsq"), format!("{subject}.ocsp")); + self.openssl(&[ + "ocsp", + "-issuer", + "issuer.pem", + "-sha256", + "-cert", + &certificate, + "-no_nonce", + "-reqout", + &request, + ])?; + let mut respond = vec![ + "ocsp", + "-index", + "responder.index", + "-CA", + "issuer.pem", + "-rsigner", + &signer, + "-rkey", + &signer_key, + "-rmd", + "sha256", + "-reqin", + &request, + "-respout", + &response, + "-ndays", + "3650", + ]; + if by_key { + respond.push("-resp_key_id"); + } + self.openssl(&respond)?; + self.read(&response) + } + + /// An RFC 3161 token over `input`, signed by the test TSA. + fn token(&self, input: &[u8]) -> Result { + self.token_under(input, TSA_CONFIG) + } + + /// An RFC 3161 token over `input`, issued under this TSA configuration. + fn token_under(&self, input: &[u8], config: &str) -> Result { + self.write("tsa.input", input)?; + self.write("tsa.serial", "01\n")?; + self.write("tsa.cnf", config)?; + self.openssl(&[ + "ts", + "-query", + "-data", + "tsa.input", + "-sha256", + "-cert", + "-no_nonce", + "-out", + "tsa.tsq", + ])?; + self.openssl(&[ + "ts", + "-reply", + "-config", + "tsa.cnf", + "-queryfile", + "tsa.tsq", + "-token_out", + "-out", + "tsa.der", + ])?; + Ok(STANDARD.encode(self.read("tsa.der")?)) + } +} + +fn certificate_values(generator: &Generator, names: &[&str]) -> Result { + let mut values = String::new(); + for name in names { + let der = generator.der(name)?; + values.push_str(""); + values.push_str(&STANDARD.encode(der)); + values.push_str(""); + } + Ok(format!( + "{values}" + )) +} + +fn revocation_values(crls: &[&Vec], responses: &[&Vec]) -> String { + let encapsulated = |list: &str, tag: &str, values: &[&Vec]| { + if values.is_empty() { + return String::new(); + } + let (open, close) = (format!(""), format!("")); + let mut text = format!(""); + for value in values { + text.push_str(&open); + text.push_str(&STANDARD.encode(value)); + text.push_str(&close); + } + text + &format!("") + }; + format!( + "{}{}", + encapsulated("CRLValues", "EncapsulatedCRLValue", crls), + encapsulated("OCSPValues", "EncapsulatedOCSPValue", responses), + ) +} + +fn stamped(token: &str) -> String { + format!( + r#"{token}"# + ) +} + +/// `signed` with these unsigned signature properties added after any it has. +fn with_properties(signed: &str, properties: &str) -> String { + if signed.contains("") { + return signed + .replacen( + "", + &format!(r#""#), + 1, + ) + .replacen( + "", + &format!("{properties}"), + 1, + ); + } + signed.replacen( + "", + &format!( + r#"{properties}"# + ), + 1, + ) +} + +/// EN 319 132-1 V1.3.1 §5.5.2.3: reference outputs, `SignedInfo`, +/// `SignatureValue`, `KeyInfo`, then every earlier unsigned property. +fn archive_input(generator: &Generator, signed: &str, earlier: &str) -> Result, String> { + let signature = signed + .find(", + signed: &str, + earlier: &str, +) -> Result, String> { + for (open, close) in [ + (""), + (""), + (""), + (""), + ] { + input.extend(canonical(generator, &element(signed, open, close)?)?); + } + for (open, close) in [ + (""), + (""), + (""), + ( + "", + ), + ] { + input.extend(canonical(generator, &element(earlier, open, close)?)?); + } + let (open, close) = ( + "", + ); + if earlier.contains(open) { + input.extend(canonical(generator, &element(earlier, open, close)?)?); + } + Ok(input) +} + +/// The `SignatureTimeStamp` property of the first signature in `signed`. +fn signature_stamp(levels: &Levels<'_>, signed: &str, id: &str) -> Result { + let value = element(signed, "")?; + let token = levels.token(&canonical(levels.generator, &value)?)?; + Ok(format!( + r#"{}"#, + stamped(&token) + )) +} + +/// Everything the structural variants share. +struct Shared<'a> { + levels: &'a Levels<'a>, + digests: &'a Digests, + typed: &'a str, + /// The validation material that follows a signature's timestamp. + tail: &'a str, + directory: &'a std::path::Path, +} + +impl Shared<'_> { + fn base(&self) -> Signature<'_> { + baseline(self.digests, self.typed, RSA_SHA256_PROFILE) + } + + /// Signs `template`'s `nodes` in order and returns the document. + fn signed(&self, name: &str, template: &str, nodes: &[&str]) -> Result { + let generator = self.levels.generator; + let mut source = format!("{name}.template.xml"); + write(&generator.work.join(&source), template)?; + for (step, node) in nodes.iter().enumerate() { + let result = format!("{name}.{step}.xml"); + generator.sign(&source, &generator.work.join(&result), node, KEY)?; + source = result; + } + super::xml::read(&generator.work.join(source)) + } + + fn long_term(&self, signed: &str) -> Result { + let stamp = signature_stamp(self.levels, signed, "ts")?; + Ok(with_properties(signed, &format!("{stamp}{}", self.tail))) + } + + /// B-LTA whose signed `Manifest` names a detached object, with the renewal + /// EN 319 132-1 §5.5.3 defines under a digest other than the Manifest's. + fn write_renewed(&self, payload: &str) -> Result<(), String> { + let profile = RSA_SHA256_PROFILE; + let generator = self.levels.generator; + let reference = format!( + r#"{}"#, + profile.digest, + STANDARD.encode(Sha256::digest(payload)) + ); + let signature = Signature { + data_reference: target_reference("sig", "#manifest", profile), + objects: format!( + r#"{reference}"# + ), + // EN 319 132-1 §6.3(k), note 8: a Manifest reference is a signed object. + formats: r##"text/plain"##.to_owned(), + ..self.base() + }; + let template = document("Manifest payload", &signature, profile); + let signed = self.signed("renewed", &template, &["sig"])?; + let material = format!( + "{}{}", + signature_stamp(self.levels, &signed, "ts")?, + self.tail + ); + let earlier = with_properties(&signed, &material); + let manifest = element(&signed, "")?; + let mut input = archive_input_over( + generator, + canonical(generator, &manifest)?, + &signed, + &earlier, + )?; + // §5.5.2.3 step 6: every ds:Object but the qualifying properties' own. + let object = element(&signed, "")?; + input.extend(canonical(generator, &object)?); + let instruction = element( + &signed, + r#"", + )?; + let renewal = format!( + r#"{}{}{}"#, + stamped(&self.levels.token(&input)?), + STANDARD.encode(Sha512::digest(payload)), + STANDARD.encode(Sha512::digest(canonical(generator, &instruction)?)), + ); + write( + &self.directory.join("b-lta-renewed-digests.xml"), + with_properties(&signed, &format!("{material}{renewal}")), + ) + } + + /// The acceptance structures, each with its own real tokens. + fn write_all(&self) -> Result<(), String> { + let profile = RSA_SHA256_PROFILE; + let countersigned = Signature { + unsigned: counter_signature("counter", "sig-value", profile), + ..self.base() + }; + let template = document("Countersigned payload", &countersigned, profile); + write( + &self.directory.join("b-lt-countersigned.xml"), + self.long_term(&self.signed("countersigned", &template, &["sig", "counter"])?)?, + )?; + let payload = "Detached levels payload\n"; + write(&self.levels.generator.work.join("detached.txt"), payload)?; + write(&self.directory.join("detached.txt"), payload)?; + self.write_renewed(payload)?; + let detached = Signature { + data_reference: detached_reference("sig", "detached.txt", profile), + mime: "text/plain", + ..self.base() + }; + let template = format!("\n{}\n", detached.render(profile)); + write( + &self.directory.join("b-lt-detached.xml"), + self.long_term(&self.signed("detached", &template, &["sig"])?)?, + )?; + let parallel = |id, properties, uri: &str, target| Signature { + id, + properties, + data_reference: target_reference(id, uri, profile), + target, + ..self.base() + }; + let template = format!( + "First payloadSecond payload\n{}{}\n", + parallel("first-sig", "first-sp", "#first", "#first-sig").render(profile), + parallel("second-sig", "second-sp", "#second", "#second-sig").render(profile) + ); + let signed = self.signed("parallel", &template, &["first-sig", "second-sig"])?; + let second = signed + .match_indices(" Result<(), String> { + let directory = results.join("dss-signatures"); + std::fs::create_dir_all(&directory).map_err(|error| error.to_string())?; + let mut failures = Vec::new(); + for (file, at, level, expected) in DSS_SIGNATURES { + let target = directory.join(file); + if !target.exists() { + let url = format!( + "https://raw.githubusercontent.com/esig/dss/{DSS_RELEASE}/dss-xades/src/test/resources/validation/{file}" + ); + let fetch = super::line(&[ + &"curl", + &"--fail", + &"--silent", + &"--show-error", + &"--output", + &target, + &url, + ]); + corpus.require(&fetch, &directory.join(format!("{file}-fetch")))?; + } + let mut probe = super::line(&[ + &"cargo", + &"run", + &"-q", + &"-p", + &"xml-sec-xades", + &"--example", + &"level_probe", + &"--", + &target, + &"-", + &at, + ]); + // The level, then "1" of stated accuracy, then the profile if a row names one. + let mut words = level.split(' '); + probe.extend(words.next().map(Into::into)); + probe.push("1".into()); + probe.extend(words.map(Into::into)); + let log = format!("{file}-{}", level.replace(' ', "-")); + let run = corpus.require(&probe, &directory.join(log))?; + let report = String::from_utf8_lossy(&run.stdout); + println!("{file} {level}: expected {expected}"); + if !report.contains(expected) { + failures.push(format!("{file} {level}")); + } + } + if failures.is_empty() { + Ok(()) + } else { + Err(format!("DSS signature outcome mismatch: {failures:?}")) + } +} + +/// `xades levels [--results DIR]`: EU DSS's own conclusion on every fixture. +pub(crate) fn run(corpus: &super::Corpus, args: &[String]) -> Result<(), crate::repo::Failure> { + let mut results = corpus.root.join("target/xades-levels-results"); + let mut args = args.iter(); + while let Some(arg) = args.next() { + match arg.as_str() { + "--results" => { + results = super::absolute(args.next().ok_or("--results needs a directory")?)?; + } + _ => return Err("usage: xades levels [--results DIR]".into()), + } + } + Ok(execute(corpus, &results)?) +} + +/// Compares DSS's conclusion on every fixture with `VERDICTS`. +pub(crate) fn execute(corpus: &super::Corpus, results: &std::path::Path) -> Result<(), String> { + std::fs::create_dir_all(results).map_err(|error| error.to_string())?; + super::dss::build(corpus, results)?; + let classpath = super::dss::classpath(corpus)?; + let fixtures = corpus + .root + .join("crates/xml-sec-xades/tests/fixtures/levels"); + let mut failures = Vec::new(); + for (file, format, indication) in VERDICTS { + let mut probe = super::line(&[ + &"java", + &"-cp", + &classpath, + &"LevelProbe", + &fixtures.join(file), + &fixtures.join("root.der"), + &"1800000000", + &results.join(file), + ]); + if file == "b-lt-detached.xml" { + probe.push(fixtures.join("detached.txt").into()); + } + let run = corpus.require(&probe, &results.join(format!("{file}-run")))?; + let report = String::from_utf8_lossy(&run.stdout).into_owned(); + println!("{file}: {}", report.trim()); + if !report.contains(&format!("format={format} ")) + || !report.contains(&format!("indication={indication} ")) + { + failures.push(file); + } + } + if !failures.is_empty() { + return Err(format!("DSS verdict mismatch: {failures:?}")); + } + dss_signatures(corpus, results) +} + +/// Writes the level fixtures and their anchor into `levels/` of the output. +pub(crate) fn generate(generator: &Generator) -> Result<(), String> { + let directory = generator.output.join("levels"); + for path in [&directory, &generator.work] { + std::fs::create_dir_all(path) + .map_err(|error| format!("create {}: {error}", path.display()))?; + } + if !(super::fixtures::NOT_BEFORE..super::fixtures::NOT_AFTER).contains(&TEST_INSTANT) { + return Err("certificate validity must contain the test instant".into()); + } + let levels = Levels { generator }; + levels.issue()?; + let digests = generator.digests()?; + let typed = format!(r#"Type="{}""#, super::fixtures::SIGNED_PROPERTIES); + let signature = baseline(&digests, &typed, RSA_SHA256_PROFILE); + let payload = if generator.units == 0 { + "Levels payload".to_owned() + } else { + (0..generator.units) + .map(|unit| format!(r#"value-{unit}"#)) + .collect() + }; + let template = document(&payload, &signature, RSA_SHA256_PROFILE); + write(&generator.work.join("levels.template.xml"), &template)?; + let target = generator.work.join("levels.xml"); + generator.sign("levels.template.xml", &target, "sig", KEY)?; + let signed = super::xml::read(&target)?; + let signature_stamp = signature_stamp(&levels, &signed, "ts")?; + write( + &directory.join("b-t.xml"), + with_properties(&signed, &signature_stamp), + )?; + write_unstated_accuracy(&levels, &signed, &directory)?; + let (root_crl, issuer_crl) = (levels.crl("root")?, levels.crl("issuer")?); + let response = levels.ocsp("signer", false)?; + // EN 319 132-1 V1.3.1 §6.3(x) requires a timestamp's own material in + // validation-data properties or in its token, not in ordinary values. + write( + &directory.join("b-lt-tsa-material-misplaced.xml"), + with_properties( + &signed, + &format!( + "{signature_stamp}{}{}", + certificate_values(generator, &["issuer", "root", "tsa", "responder"])?, + revocation_values(&[&root_crl, &issuer_crl], &[&response]), + ), + ), + )?; + let tail = format!( + "{}{}{}{}", + certificate_values(generator, &["issuer", "root", "responder"])?, + revocation_values(&[&root_crl], &[&response]), + certificate_values(generator, &["tsa", "issuer", "root"])?, + revocation_values(&[&issuer_crl, &root_crl], &[]), + ); + let material = format!("{signature_stamp}{tail}"); + let long_term = with_properties(&signed, &material); + write(&directory.join("b-lt.xml"), &long_term)?; + let by_key = levels.ocsp("signer", true)?; + write( + &directory.join("b-lt-responder-by-key.xml"), + with_properties( + &signed, + &material.replace( + &revocation_values(&[&root_crl], &[&response]), + &revocation_values(&[&root_crl], &[&by_key]), + ), + ), + )?; + write_status_variants( + &levels, + &signed, + &material, + [&root_crl, &issuer_crl, &response], + &directory, + )?; + Shared { + levels: &levels, + digests: &digests, + typed: &typed, + tail: &tail, + directory: &directory, + } + .write_all()?; + let revoked = levels.crl_revoking("issuer", "tsa")?; + write( + &directory.join("b-lt-tsa-revoked.xml"), + with_properties( + &signed, + &material.replace( + &revocation_values(&[&issuer_crl, &root_crl], &[]), + &revocation_values(&[&issuer_crl, &revoked, &root_crl], &[]), + ), + ), + )?; + write_archival(&levels, &signed, &material, &directory)?; + for name in ["root", "issuer", "outsider"] { + write(&directory.join(format!("{name}.der")), generator.der(name)?)?; + } + Ok(()) +} + +/// B-LT variants of `material`: a responder only local configuration authorizes, +/// conflicting complete and delta evidence, and a delta in the timestamp's data. +fn write_status_variants( + levels: &Levels<'_>, + signed: &str, + material: &str, + [root_crl, issuer_crl, response]: [&Vec; 3], + directory: &std::path::Path, +) -> Result<(), String> { + let generator = levels.generator; + let good = revocation_values(&[root_crl], &[response]); + let variant = |name: &str, material: String| { + write(&directory.join(name), with_properties(signed, &material)) + }; + let configured = levels.ocsp_from("outsider", "signer", false)?; + variant( + "b-lt-configured-responder.xml", + material + .replace(&good, &revocation_values(&[root_crl], &[&configured])) + .replace( + &certificate_values(generator, &["issuer", "root", "responder"])?, + &certificate_values(generator, &["issuer", "root"])?, + ), + )?; + let revoked = levels.crl_revoking("issuer", "signer")?; + variant( + "b-lt-conflicting-status.xml", + material.replace( + &good, + &revocation_values(&[root_crl, &revoked], &[response]), + ), + )?; + let delta = levels.delta_crl("issuer", Some("signer"))?; + variant( + "b-lt-conflicting-delta.xml", + material.replace( + &good, + &revocation_values(&[root_crl, issuer_crl, &delta], &[response]), + ), + )?; + let quiet = levels.delta_crl("issuer", None)?; + variant( + "b-lt-tsa-delta.xml", + material.replace( + &revocation_values(&[issuer_crl, root_crl], &[]), + &revocation_values(&[issuer_crl, &quiet, root_crl], &[]), + ), + ) +} + +/// RFC 3161 §2.4.2 makes accuracy optional; real TSAs often omit it. +fn write_unstated_accuracy( + levels: &Levels<'_>, + signed: &str, + directory: &std::path::Path, +) -> Result<(), String> { + let value = element(signed, "")?; + let unstated = levels.token_under( + &canonical(levels.generator, &value)?, + &TSA_CONFIG.replace("accuracy=secs:1\n", ""), + )?; + write( + &directory.join("b-t-no-accuracy.xml"), + with_properties( + signed, + &format!( + r#"{}"#, + stamped(&unstated) + ), + ), + ) +} + +/// B-LTA over `material`, then a later archive that covers the earlier one, +/// as renewal over time does. +fn write_archival( + levels: &Levels<'_>, + signed: &str, + material: &str, + directory: &std::path::Path, +) -> Result<(), String> { + let generator = levels.generator; + let long_term = with_properties(signed, material); + let archive = levels.token(&archive_input(generator, signed, &long_term)?)?; + let first_archive = format!( + r#"{material}{}"#, + stamped(&archive) + ); + let archival = with_properties(signed, &first_archive); + write(&directory.join("b-lta.xml"), &archival)?; + let renewal = levels.token(&archive_input(generator, signed, &archival)?)?; + write( + &directory.join("b-lta-renewed.xml"), + with_properties( + signed, + &format!( + r#"{first_archive}{}"#, + stamped(&renewal) + ), + ), + ) +} diff --git a/tools/xml-sec-tools/src/xades/mod.rs b/tools/xml-sec-tools/src/xades/mod.rs index 7be968ed..d5db5ccf 100644 --- a/tools/xml-sec-tools/src/xades/mod.rs +++ b/tools/xml-sec-tools/src/xades/mod.rs @@ -13,6 +13,7 @@ pub(crate) mod check; pub(crate) mod corpus; pub(crate) mod dss; pub(crate) mod fixtures; +pub(crate) mod levels; pub(crate) mod package; pub(crate) mod process; pub(crate) mod xml; @@ -300,7 +301,7 @@ pub(crate) fn absolute(path: &str) -> Result { } pub(crate) fn run(mut args: impl Iterator) -> Result<(), Failure> { - let usage = "usage: xades check|corpus|dss|binding|fixtures|package ..."; + let usage = "usage: xades check|corpus|dss|binding|fixtures|levels|package ..."; let action = args.next().ok_or(usage)?; let args: Vec = args.collect(); let corpus = Corpus::from_env(); @@ -310,6 +311,7 @@ pub(crate) fn run(mut args: impl Iterator) -> Result<(), Failure> "dss" => dss::run(&corpus, &args), "binding" => binding::run(&corpus, &args), "fixtures" => fixtures::run(&corpus, &args), + "levels" => levels::run(&corpus, &args), "package" => package::run(&corpus, &args), _ => Err(usage.into()), } diff --git a/tools/xml-sec-tools/src/xades/package.rs b/tools/xml-sec-tools/src/xades/package.rs index b5f74d4a..530cf55a 100644 --- a/tools/xml-sec-tools/src/xades/package.rs +++ b/tools/xml-sec-tools/src/xades/package.rs @@ -14,7 +14,7 @@ const NOTICES: [&str; 2] = ["LICENSE", "LICENSE-THIRD-PARTY"]; const COMMIT: &str = "COMMIT"; /// Maintained corpus files outside the per-case directories. -const DOCUMENTS: [&str; 14] = [ +const DOCUMENTS: [&str; 15] = [ ".gitattributes", "README.md", "PROVENANCE.md", @@ -24,6 +24,7 @@ const DOCUMENTS: [&str; 14] = [ "dss/pom.xml", "dss/src/main/java/Probe.java", "dss/src/main/java/BindingProbe.java", + "dss/src/main/java/LevelProbe.java", "dss-evidence/expectations.json", "dss-investigation/README.md", "dss-investigation/expectations.json", diff --git a/tools/xmlsec1/Cargo.toml b/tools/xmlsec1/Cargo.toml index ad7da618..f0d0d8e5 100644 --- a/tools/xmlsec1/Cargo.toml +++ b/tools/xmlsec1/Cargo.toml @@ -46,8 +46,8 @@ dsa = { version = "0.7", features = ["hazmat"] } md-5 = { version = "0.11", features = ["oid", "zeroize"] } pkcs8 = { version = "0.11", features = ["encryption", "pem"] } x509-parser = "0.18" -structured-asn1 = { version = "0.18.0", default-features = false, features = ["alloc", "std"] } -structured-pkix = { version = "0.18.0", default-features = false, features = ["alloc", "std"] } +structured-asn1 = { version = "0.20.0", default-features = false, features = ["alloc", "std"] } +structured-pkix = { version = "0.20.0", default-features = false, features = ["alloc", "std"] } zeroize = "1" base64 = "0.23" thiserror = "2" diff --git a/vendor/sxd-document-no-unsafe/Cargo.toml b/vendor/sxd-document-no-unsafe/Cargo.toml index 3006683f..0b9b3996 100644 --- a/vendor/sxd-document-no-unsafe/Cargo.toml +++ b/vendor/sxd-document-no-unsafe/Cargo.toml @@ -31,5 +31,5 @@ workspace = true [dependencies] peresil = "0.3.0" -structured-asn1 = { version = "0.18.0", default-features = false, features = ["alloc"] } +structured-asn1 = { version = "0.20.0", default-features = false, features = ["alloc"] } typed-arena = "2.0" From 89adc5d32c1e418469c5f2f21f32a2d61b356013 Mon Sep 17 00:00:00 2001 From: Dmitry Prudnikov Date: Sat, 31 Oct 2026 23:49:10 +0200 Subject: [PATCH 2/4] fix(tools): build the sized payload without format collect The level fixture generator collected formatted strings, which the workspace lint set refuses. --- tools/xml-sec-tools/src/xades/levels.rs | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/tools/xml-sec-tools/src/xades/levels.rs b/tools/xml-sec-tools/src/xades/levels.rs index d9780cab..fcf4cfcd 100644 --- a/tools/xml-sec-tools/src/xades/levels.rs +++ b/tools/xml-sec-tools/src/xades/levels.rs @@ -750,6 +750,22 @@ pub(crate) fn execute(corpus: &super::Corpus, results: &std::path::Path) -> Resu dss_signatures(corpus, results) } +/// The signed payload: a short text, or `units` elements for a sized document. +fn payload(units: usize) -> String { + if units == 0 { + return "Levels payload".to_owned(); + } + let mut items = String::new(); + for unit in 0..units { + std::fmt::Write::write_fmt( + &mut items, + format_args!(r#"value-{unit}"#), + ) + .expect("writing to a String cannot fail"); + } + items +} + /// Writes the level fixtures and their anchor into `levels/` of the output. pub(crate) fn generate(generator: &Generator) -> Result<(), String> { let directory = generator.output.join("levels"); @@ -765,13 +781,7 @@ pub(crate) fn generate(generator: &Generator) -> Result<(), String> { let digests = generator.digests()?; let typed = format!(r#"Type="{}""#, super::fixtures::SIGNED_PROPERTIES); let signature = baseline(&digests, &typed, RSA_SHA256_PROFILE); - let payload = if generator.units == 0 { - "Levels payload".to_owned() - } else { - (0..generator.units) - .map(|unit| format!(r#"value-{unit}"#)) - .collect() - }; + let payload = payload(generator.units); let template = document(&payload, &signature, RSA_SHA256_PROFILE); write(&generator.work.join("levels.template.xml"), &template)?; let target = generator.work.join("levels.xml"); From fa49ebc79c351bf5634791df1b75fcdefb1e5ab9 Mon Sep 17 00:00:00 2001 From: Dmitry Prudnikov Date: Sun, 1 Nov 2026 00:11:09 +0200 Subject: [PATCH 3/4] fix(xades): hold status signers to the operation policy - The timestamp token encoding moves from a caller input to VerificationPolicy, so one compiled snapshot governs acceptance. - CRL and OCSP signature checks enforce the RSA/DSA key policy, which no certificate path reaches for a configured responder. - A timestamp signer may come from the document, and an OCSP signer from the caller's anchors or configured responders, as tokens and responses may omit their certificates. Each fix carries a regression test seen failing. The level fixtures are regenerated with two omitted-certificate cases. --- crates/xml-sec-config/src/settings.rs | 17 +- crates/xml-sec-config/tests/configuration.rs | 21 +++ crates/xml-sec-xades/examples/level_probe.rs | 14 +- crates/xml-sec-xades/src/level.rs | 56 +++++-- crates/xml-sec-xades/src/lib.rs | 1 - crates/xml-sec-xades/src/status.rs | 3 + .../levels/b-lt-configured-responder.xml | 78 ++++----- .../levels/b-lt-conflicting-delta.xml | 78 ++++----- .../levels/b-lt-conflicting-status.xml | 78 ++++----- .../fixtures/levels/b-lt-countersigned.xml | 152 ++++++++--------- .../tests/fixtures/levels/b-lt-detached.xml | 78 ++++----- .../fixtures/levels/b-lt-responder-by-key.xml | 78 ++++----- .../tests/fixtures/levels/b-lt-tsa-delta.xml | 78 ++++----- .../levels/b-lt-tsa-material-misplaced.xml | 78 ++++----- .../fixtures/levels/b-lt-tsa-revoked.xml | 78 ++++----- .../levels/b-lt-uncertified-responder.xml | 90 ++++++++++ .../levels/b-lt-uncertified-token.xml | 90 ++++++++++ .../tests/fixtures/levels/b-lt.xml | 78 ++++----- .../fixtures/levels/b-lta-renewed-digests.xml | 78 ++++----- .../tests/fixtures/levels/b-lta-renewed.xml | 78 ++++----- .../tests/fixtures/levels/b-lta.xml | 78 ++++----- .../tests/fixtures/levels/b-t-no-accuracy.xml | 78 ++++----- .../tests/fixtures/levels/b-t-parallel.xml | 156 +++++++++--------- .../tests/fixtures/levels/b-t.xml | 78 ++++----- .../tests/fixtures/levels/issuer.der | Bin 834 -> 834 bytes .../tests/fixtures/levels/outsider.der | Bin 861 -> 861 bytes .../tests/fixtures/levels/root.der | Bin 796 -> 796 bytes crates/xml-sec-xades/tests/levels.rs | 49 ++++-- docs/policy-schema-v1.md | 1 + interop/xades/README.md | 4 +- interop/xades/SHA256SUMS | 2 +- src/policy.rs | 14 ++ src/policy/profiles/composition.rs | 17 +- src/xmldsig/pkix.rs | 89 ++++++++++ src/xmldsig/verify/session/lookup.rs | 28 ++-- tools/xml-sec-tools/src/xades/levels.rs | 75 +++++++-- 36 files changed, 1209 insertions(+), 762 deletions(-) create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-responder.xml create mode 100644 crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-token.xml diff --git a/crates/xml-sec-config/src/settings.rs b/crates/xml-sec-config/src/settings.rs index bd8d13df..8347f59b 100644 --- a/crates/xml-sec-config/src/settings.rs +++ b/crates/xml-sec-config/src/settings.rs @@ -15,8 +15,8 @@ use xml_sec::{ KeyEstablishmentPolicy, KeySourceKind, KeySourcePolicy, KeyTrustPolicy, ManifestProcessing, OpcRelationshipEdition, PolicySet, PolicyValidity, ResourcePolicy, RsaKeyPolicy, RsaPssPermission, SameDocumentIdSemantics, SignatureConstraints, SigningPolicy, - TransformPolicy, UriPolicy, VerificationPolicy, VerificationTrustMode, XmlInputPolicy, - XsltStylesheetSemantics, + TimestampTokenEncoding, TransformPolicy, UriPolicy, VerificationPolicy, + VerificationTrustMode, XmlInputPolicy, XsltStylesheetSemantics, }, provider::{KeyEncapsulationAlgorithm, X509SignatureAlgorithm}, xmldsig::{ @@ -527,6 +527,14 @@ fn verification(p: &mut VerificationPolicy, t: &Table, syntax_only: bool) -> Res DetachedDigestAttestation::Accepted ); } + "timestamp_token_encoding" => { + p.timestamp_token_encoding = choice!( + value, + key, + TimestampTokenEncoding::Declared, + TimestampTokenEncoding::Ber + ); + } _ => signature_fields!(p, key, value), } } @@ -1052,6 +1060,7 @@ fn verification_snapshot(p: &VerificationPolicy) -> Result { transforms: _, manifest_processing: _, detached_digest_attestation: _, + timestamp_token_encoding: _, xml: _, resources: _, } = p; @@ -1062,6 +1071,10 @@ fn verification_snapshot(p: &VerificationPolicy) -> Result { "detached_digest_attestation".into(), named(p.detached_digest_attestation), ); + t.insert( + "timestamp_token_encoding".into(), + named(p.timestamp_token_encoding), + ); Ok(Value::Table(t)) } diff --git a/crates/xml-sec-config/tests/configuration.rs b/crates/xml-sec-config/tests/configuration.rs index 242b701f..c0d29615 100644 --- a/crates/xml-sec-config/tests/configuration.rs +++ b/crates/xml-sec-config/tests/configuration.rs @@ -242,6 +242,27 @@ fn detached_payload_settings_compose_restrictively() { ); } +#[test] +fn a_profile_overlay_cannot_relax_the_timestamp_token_encoding() { + // RFC 5652 BER drops the EN 319 132-1 §5.1.3 assertion, so an overlay may + // not choose it over a base that holds tokens to their declared encoding. + use xml_sec::policy::TimestampTokenEncoding; + let relaxed = effective( + &config("[profiles.team.verification]\ntimestamp_token_encoding='Ber'"), + "team", + ); + assert_eq!( + relaxed + .compiled() + .verification() + .unwrap() + .timestamp_token_encoding, + TimestampTokenEncoding::Declared + ); + let output = relaxed.to_toml().unwrap(); + assert!(output.contains("timestamp_token_encoding = \"Declared\"")); +} + #[test] fn bounded_readers_and_paths_admit_bytes_before_parsing() { // The exact boundary passes, one extra byte fails without heap growth for diff --git a/crates/xml-sec-xades/examples/level_probe.rs b/crates/xml-sec-xades/examples/level_probe.rs index fb2cecc9..ac7f9b96 100644 --- a/crates/xml-sec-xades/examples/level_probe.rs +++ b/crates/xml-sec-xades/examples/level_probe.rs @@ -16,14 +16,12 @@ use structured_cms::timestamp::{Accuracy, PolicyAccuracy, Token}; use structured_pkix::Certificate; use structured_pkix::temporal::LeapTable; use xml_sec::XmlDocument; -use xml_sec::policy::{Instant, VerificationPolicy}; +use xml_sec::policy::{Instant, TimestampTokenEncoding, VerificationPolicy}; use xml_sec::xmldsig::{ DefaultKeyResolver, KeyResolverConfig, VerificationRequest, VerifyContext, with_verified_request, }; -use xml_sec_xades::{ - AuthorityAccuracy, ConfiguredResponder, Inputs, Requirements, TokenProfile, validate, -}; +use xml_sec_xades::{AuthorityAccuracy, ConfiguredResponder, Inputs, Requirements, validate}; /// Every base64 value between `open` and `close` in the source text. fn values(text: &str, tag: &str) -> Vec> { @@ -109,9 +107,9 @@ fn main() -> Result<(), Box> { ); }; let seconds = rest.first().map(|value| value.parse()).transpose()?; - let token_profile = match rest.get(1) { - Some(profile) if profile == "cms" => TokenProfile::Cms, - _ => TokenProfile::Etsi, + let timestamp_token_encoding = match rest.get(1) { + Some(profile) if profile == "cms" => TimestampTokenEncoding::Ber, + _ => TimestampTokenEncoding::Declared, }; let requirements = match level.as_str() { "b" => Requirements::Basic, @@ -146,6 +144,7 @@ fn main() -> Result<(), Box> { let mut policy = VerificationPolicy::default(); policy.key_trust.verify_x509_chains = true; policy.key_trust.verification_time = Instant::new(at.parse()?, 0); + policy.timestamp_token_encoding = timestamp_token_encoding; let context = VerifyContext::new().policy(policy).key_resolver(&resolver); let document = XmlDocument::parse(text.as_str())?; let request = VerificationRequest::default(); @@ -179,7 +178,6 @@ fn main() -> Result<(), Box> { println!("signature: {:?}", entry.result().as_ref().map(|r| r.status)); let inputs = Inputs { requirements, - token_profile, anchors: &references, certificates: &others, utc: &utc, diff --git a/crates/xml-sec-xades/src/level.rs b/crates/xml-sec-xades/src/level.rs index 2a6888f1..62014a29 100644 --- a/crates/xml-sec-xades/src/level.rs +++ b/crates/xml-sec-xades/src/level.rs @@ -47,6 +47,7 @@ use structured_xades::timestamp::{ use structured_xades::unsigned::Requirements; use structured_xades::xml::{Access, Xml}; use xml_sec::document::{DocumentIdentity, NodeIdentity}; +use xml_sec::policy::TimestampTokenEncoding; use xml_sec::xmldsig::cms::CmsProvider; use xml_sec::xmldsig::{VerifiedSession, X509ChainError}; @@ -70,10 +71,6 @@ pub type Level<'a> = Assessment<'a, NoCredential, N, D, G>; pub struct Inputs<'a> { /// The structural level to establish. pub requirements: Requirements, - /// How timestamp tokens are read. [`TokenProfile::Cms`] takes RFC 5652 BER, - /// so a met level then asserts nothing about EN 319 132-1 §5.1.3; - /// [`TokenProfile::Etsi`] holds each token to its declared encoding. - pub token_profile: TokenProfile, /// DER certificates that end timestamp and revocation-authority paths. pub anchors: &'a [&'a [u8]], /// Further DER certificates a path may use, beyond the document's. @@ -177,7 +174,10 @@ pub fn validate( let timing = (requirements != Requirements::Basic).then_some(Timing { utc: inputs.utc, accuracies: inputs.accuracies, - profile: inputs.token_profile, + profile: match session.timestamp_token_encoding() { + TimestampTokenEncoding::Declared => TokenProfile::Etsi, + TimestampTokenEncoding::Ber => TokenProfile::Cms, + }, }); with_stage( session, @@ -266,7 +266,7 @@ fn timed( /// nothing: a path still has to end at a caller anchor. fn certificate_pool<'p, 't>( pools: &'p Pools<'p, 't>, - supplied: &'p [Certificate<'t>], + supplied: [&'p [Certificate<'t>]; 2], memory: &Memory, ) -> Result>, Error> { let mut pool = memory.vector(); @@ -285,7 +285,7 @@ fn certificate_pool<'p, 't>( pool.try_push(certificate)?; } } - for certificate in supplied { + for certificate in supplied.into_iter().flatten() { pool.try_push(certificate)?; } Ok(pool.into_owned()) @@ -298,13 +298,19 @@ type TokenFailure = (N, TimestampFailure); fn token_signer<'p, 't>( pools: &'p Pools<'p, 't>, ordinal: usize, - supplied: &'p [Certificate<'t>], + [supplied, incorporated]: [&'p [Certificate<'t>]; 2], supplied_parent: &'p Reader<'t>, ) -> Result, &'p Reader<'t>)>, ValidationError> { let reading = &pools.tokens.readings()[ordinal]; let named = reading.token().signer().sid(); let carried = reading.token().message().certificates(); - for (certificates, parent) in [(carried, reading.reader()), (supplied, supplied_parent)] { + // RFC 5652 §5.1: a token may omit the signer's certificate, which the + // document's own validation data then supplies. + for (certificates, parent) in [ + (carried, reading.reader()), + (supplied, supplied_parent), + (incorporated, supplied_parent), + ] { for certificate in certificates { if matches!( matches_certificate_in(named, certificate, parent) @@ -318,6 +324,21 @@ fn token_signer<'p, 't>( Ok(None) } +/// The document's certificates as DER. Each value was read in a session of its +/// own, so a check that needs a shared parent reads these bytes again. +fn incorporated_certificates<'p>( + pools: &Pools<'p, 'p>, + memory: &Memory, +) -> Result, Error> { + let mut certificates = memory.vector(); + for value in pools.view.values() { + if let Value::Certificate(certificate) = &value.value { + certificates.try_push(certificate.as_bytes())?; + } + } + Ok(certificates.into_owned()) +} + /// No token extension is recognized, so a critical one refuses its token. fn unrecognized() -> impl FnMut(&TokenExtension<'_>, &Execution<'_>) -> Result { |_, _| Ok(false) @@ -328,7 +349,7 @@ fn token_actors<'p, 't, W: Work>( stage: &'p Stage<'_, '_, '_, '_, W>, inputs: &'p Inputs<'t>, pools: &'p Pools<'p, 't>, - supplied: &'p [Certificate<'t>], + supplied: [&'p [Certificate<'t>]; 2], supplied_parent: &'p Reader<'t>, cms: &CmsProvider<'_>, ) -> Result>, TokenFailure>, ValidationError> { @@ -470,11 +491,20 @@ fn frozen( let access = stage.access; let anchors = read_certificates(stage.parser, inputs.anchors)?; let supplied = read_certificates(stage.parser, inputs.certificates)?; + let mut configured = memory.vector(); + configured + .try_reserve_exact(inputs.responders.len()) + .map_err(Error::from)?; + for entry in inputs.responders { + configured.try_push(entry.responder).map_err(Error::from)?; + } + let configured = configured.into_owned(); + let responders = read_certificates(stage.parser, &configured)?; let supplied_parent = stage .parser .read(&[], 0) .map_err(ValidationError::Operation)?; - let pool = certificate_pool(pools, &supplied, memory)?; + let pool = certificate_pool(pools, [&supplied, &responders], memory)?; let mut anchored = memory.vector(); anchored .try_reserve_exact(anchors.len()) @@ -493,11 +523,13 @@ fn frozen( }; let external = External::read(stage.parser, inputs, &supplied_parent)?; let cms = session.cms_provider(); + let document_der = incorporated_certificates(pools, memory)?; + let incorporated = read_certificates(stage.parser, &document_der)?; let actors = token_fact!(token_actors( stage, inputs, pools, - &supplied, + [&supplied, &incorporated], &supplied_parent, &cms )); diff --git a/crates/xml-sec-xades/src/lib.rs b/crates/xml-sec-xades/src/lib.rs index 54b043ba..ef51b62f 100644 --- a/crates/xml-sec-xades/src/lib.rs +++ b/crates/xml-sec-xades/src/lib.rs @@ -48,7 +48,6 @@ pub use level::{ }; pub use path::CounterPathError; pub use status::{StatusError, StatusFailure}; -pub use structured_xades::timestamp::TokenProfile; pub use structured_xades::unsigned::Requirements; /// Original document identity and generation, as seen by the shared core. diff --git a/crates/xml-sec-xades/src/status.rs b/crates/xml-sec-xades/src/status.rs index b5e4d2cf..3807d6be 100644 --- a/crates/xml-sec-xades/src/status.rs +++ b/crates/xml-sec-xades/src/status.rs @@ -215,9 +215,12 @@ fn signed_responses<'x, W: Work>( let verifier = session.revocation_verifier(); let mut signed = memory.vector(); for response in responses { + // RFC 6960 §4.2.1: a response may carry no certificates, so its signer + // can be known only to the caller. Authorization stays per target. for candidate in response .certificates() .iter() + .chain(authorities.anchors.iter()) .chain(authorities.pool.iter().copied()) { let key = WorkingKey::standing(candidate.tbs().public_key()); diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml index 682491a0..701d2322 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-configured-responder.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml index d271e183..993d3e8e 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-delta.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIB2DCBwQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1owJzAlAhQS0/5qlL2vnLqDMiJpt2dFeI64KhcNMjYxMDAxMDAwMDAwWqA+MDwwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYDVR0bAQH/BAMCAQEwCgYDVR0UBAMCAQIwDQYJKoZIhvcNAQELBQADggEBAGT75au1MO01G3qFbe3GagoPmWZUMhwskgtroSPAawecMVMpsGBVVPiVTrl3pw59/JhfF+t1c4LFJo5JcVD+twiZR7QTnIGIWrELeeqLZzP84EDVKmqaWGrBU178xqHQWfArBp/a5lK8K4dWX3ksZ2H3Qgn5qruvszo0eXZt3UI/cNLjSkYXED6xoEC7wsfk8huIB1YgzzyljexHBV/DsGaaF/5NPORCRGhASQU1kOUk41yPIJLYEz/86+NI0TD1eA01riLj27OVuZAnatR8kptk3/uSGSK/FgKtzRWo0ohL35y9ehgGLuGvRsOz+Yv3awJPiqoZQe/g/BXpQe8fDUc=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIB2DCBwQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0M1oXDTM2MTAyODIyMDE0M1owJzAlAhQj6aFmifmCbenFH02aAkV+7S6zxxcNMjYxMDAxMDAwMDAwWqA+MDwwHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYDVR0bAQH/BAMCAQEwCgYDVR0UBAMCAQIwDQYJKoZIhvcNAQELBQADggEBALpjQs6ahitQFLhnUj5gAg6bq5EwEV9mdM47/1jt7QcU/XjGIHtmHco4S6d7rfkdOdOjPHGqbLU3mCJc1wR2BkWCjdB+ya0s54KjmMpasfAWv7G353bSB2afvJZ9fBHDmSL3o/qh9UqgZu4K3sKNAjzpXaW9tjCij5aRxqOI9s9lu+tofPTcKbl1y0o9GYBCrNyDBCgnJ09yGCEZ/zY0iT5a6qhPyHXLCsa33ibX69QkxIkcQ+GMDjcqKTd0q1jVkoMjF553tSEkcZ4OZyHF4c+dyBUTTsmjkH5QfFRBDoj9F7M1+lDjjKFWFosSSDOqOGJV7qC/l9eUCgjgqjbSpe4=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1MaCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEnve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJTEoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIfbToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmhLZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8GA1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IBAQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5aXwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/JuPKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6MLRhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/RIK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyifVL7mBUrNNo985oDyR+xacQV7MIIDGDCCAgCgAwIBAgIUdKkoW19XYcrWuD6fg5YI3Mr67PowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+axd1136T+c2X41gOfkSBUz3jIZ6omZPYN7VCtdu5HJT+5MLK2MD6xAe/TpUqDAraVYTHAJILjd/7mh4Lfsi3fnMvqelftFI8A6O+x/aiM69YHKuBnJBIvRllVluw0I+yiliKjeINw4GqUa3TKezs7NkV1R794PzA+/EwW3L5X0M1YNwdUVjI/v9knc7a1H32xXlIRMBpvVb80j6/u4pOS5Mc/j0vTRjl7qzBzPFsYrVPvIs+ZVpVh/Qxko+N1q96AdVj2hkosQb4iMXV6WaHXijg7Gt8e5Y2+12r0r/q45hcCSamdh9QKG6MeU0xMyItZoa//HX3/tXr3Da41ib/AgMBAAGjQjBAMB0GA1UdDgQWBBQUBPmNKWYSP62c8mUyPtevHJ+pxzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAZnFH4dgvrQyyaX0Lcic9oEDB1WB+e7zYYkvyIyiuP+LSeGoAK0AvrcpckGqcHv9xgpLRyhWOme8Rj5dMo4bAcEGy+zaogUelJzafcDzLQg1T5lLMOy0Nx7eDSfrwNr96tVafZfXw8PfBz2XXgcZ2tfJf+Xz6zRnA3aOWzyql5xHAMKjUVWeyXxI8XJ/2oyrD2SwRQ7k6nvzWkQPV4SUglsAvmH4j5bbGhAis6zCYeCEPL/8By5VvndeMBzHhGHH1sAp2JjvStScqw0Y1qfLn4ezb53OQ/rhaYgxk4FZ9bqbso1XI5KjHkLrihPL2RrAlF0X6Tc1lUJzoeBe8qtgtnA==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml index ed992195..795d842b 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-conflicting-status.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1owJzAlAhQS0/5qlL2vnLqDMiJpt2dFeI64KhcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBALF0oPxWZkQ+GsWAzMABJcst4OQJC+uRDKZ81IBrsBfVcvynlcUpaJgVCRYSveUVquieuJuLDI9zC+2TYPOFjf1odWbK8aVVHcwx2gG8vZmhfldpun5xXWo+fJgZE4B6bZXsXE4AKt3CiN+K2/inNftRes6I5zbU+EKyH7uQCBEAXr2ETL48iS4TsBec9TSYTFLh49N4006wdmoxF54m4QDCtbKiIouyLDOXI+33kuffb9gTZA7wAR/NsVkAdp0j2owzpNz9yK/lNyPcHk/yih4xF60D/rrg8jWEN8OTqZX1aFBPW9JNQxVHaxib+/h0cEwHrXouJxLfJ1C4Jdu96Pw=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0M1oXDTM2MTAyODIyMDE0M1owJzAlAhQj6aFmifmCbenFH02aAkV+7S6zxxcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBAL+siGrbAjMyRBkXqzEYowpLAdXmv3uklx55ZhbkzMqIOOm7niL4SnyOn4Kz+3cL7OQuALQhd92VFochULK9rjxi4FRytqqt9rr3K2AXEUkE5gwklByWEWRYNpzapEbLIlTYhjZa1WnuWbOwFElr2nIN6FCZtxlzs4OTF93djKkT7QjeWxzhZ1pp4rF1/EO7Xq5+VwFun1GZ5dunZ9J5iOx8O/+g5BB6qmRVfXg1VlmAnTYCr0nFVB+2+AOEThI8F1Bry48H5GC8iVcF6makbRXwzCcaQT+2d0STY2Wv62RiJVvVGcooN54UYeJG8vIuYomePsltEKWwdq6UUcWScoo=MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml index 2569703c..03f76dfb 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-countersigned.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - zekRlXUqBDe4sM+NrPhpz1LmyoVtT6rJ6zOe9fj3U0m+RMWl3+JRfmXaUxzw8VTi -LtkK7QGjqCT8NP6xJNReMFX8BPdFrFmg7WOUl47drmNTCuOaBAU+4CC3BoEYyfVe -VA/LOpDBghbwNLyPo1hmr0ge37KHO1+ZrvLb3cnMEI+FoU0A9lfGd7ZpaBvoCBVC -Ib2dDFvk0V+A63sDOj1o7YkAIpdZRUViLNi1oh3kTIuJ3SqqQJ8aRo1ebDaty2L2 -XV9haD5Sdx9hjIsrYM3a0muFYFgb8I5REXAd2ZysrNb2+X0ttBJlZT589Ens32bN -ZcFGJQ+eEAuCZopRDrfjiQ== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + mWZS03yroqhuiCGLBuuYZOinEAKqDJ8feAWy+BZW/zkd4jeCPciU91qR1HxY3ibe +IevUnEDXA0u3ruJEeHgK+IlB9j/dypyw32U6SNF/mY82b6LBVIAbz6pYUb0tQhNn +iukhSd6qONE84iFve9JOzsyValmLcuejgPC0uFKQ9OtJIuojp70WDAMCwzVFAMul +5znJzm1ugpOqlblV4FR3xgSAHk03WEhvAgz88uLcDB/EboZFxvFOr9WFySqrYfVY +TRTKwztS/6cNnBNEPAP9Fx1TJqpN8aAL412i7iuNasbdT3d20UJ5XNLVO0gTk2Yg +e+4lHdSiPl8OYINUAZLXnQ== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -93,56 +93,56 @@ ARrAZvqlC+ytq8wqC7ARLBIl - E523pHG09Q+dJPWK4g0Kcz4E8vVrwMTee56OeyxdbfA= + J3ZViDGUKgt0+FQNQu9ACG3PLEEr7YV+0tvB0qvgo8w= - BiJiEs+RgSWWGBvD/pVoL3EaJbDd2jDZIN38+elnBucj1mfRyIazp/3m7SQEgA+S -TyhU+GfqYiJ90dWOmxKK41OliE90TkWwqkLgmfO8e0xcgBMnyDqL/KMk+D46xS07 -ZN+dKfRUgBr21LlMOSs8LH/xQ6aMJyZeAs3oNTpYKXDsT14RlKAJb5LDSsTt25/k -Xe5uVk8w15iZfCPQ10y8Z0srWWMaaQgK5od8O8AKKQ97YZI5qobbaPvO3Cf9/a2b -XeQ/u9xoTkFSTWi8KjDH2fO76UFEr4leyh7hTFiq5NX26QEV6kaM4pEVHhta4SO8 -piGX1lJZRs4TxaEpFtzgOw== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + JjZ7FXBggnn8oGE92kfC9h5r2JQBjGLxttGfRhlfLsvE8pobyesHTegnY8OX68IH +3fXtZuOU3QnSb/bGV7VeMWST3ikzCLMws4MoMxdnnsDyCvucBuPzUPC8F6M7elPS +JteHEAVSBzUj/0BbOOawq6H2TcdZHRIgeM6acTepXWfsN+tNg9beLAEGwZ7gAtFG +Xe0uLArwgsTwInSJkdNeBCl6u+Yr6W4oPfFsABRlp6nQYucMNEDRQPPbu6t6+9SO +hmO/XfZGZvtbGvepubONMpMr0d5kJ6sHlvqFFl9krQLwuM9Tg6weJq597L+fpiaK +aD9nGKpzu4pQF/aNP+Gxow== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml index 7b28676e..dcb9481f 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-detached.xml @@ -11,52 +11,52 @@ - ybZ++lnCwgpeLdF6ZMqiXaXQtHqBgANIDPQSWUr+8Xc= + VBgjmf4sR7pzUq+QJnZvbhFZ6WG32lG2ZWY9mYWL3B0= - sBBSokcEcOX7X1b5AUYUlRNde7hPL7ITAdHJrewYLmYq69y+rjhPiL96lwJNGWdS -nFgavzNRxu2zigfJGpq57OHrmIn5p9yVc0bGMMlR+VV4wXsZiSkD+3nI5f/eQwZx -3iNlRGqb0B7FJmPqVoM503AToZt+LRtkCqJXzQjCZWJmaWd8mF6lPe8XsB4cYjQt -6GTgqKN4YNptfJW5kekAQMERao6LMIrxMJ6FEp6YNxpCSlwWemnehZQK3bGL5esf -GVl4FKmSSf3Qf3NSoHpx1FPgU+ROtMOeqD9ClpIiS+XQrsNpMrQbwabt7ylHRohD -u0CcM1alvxBQdlecGum9EQ== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + Py3W2jaug9S56Dw5itedxinZXvJyHCTTVSnOyPKPas4kcBQ1ZiIJF2fgqoYTeTBU +Vl1yhnrHWs79LJLg/KYhaKsGG/07XVS+0Ui8Uby71Bi60LDx0ashPB+EQqCkBVXA +UgDcHk0jBkibdJQgq2Wp4i5RrdBlmW+0TgiMrnhi7Bxt4qBlHiOzKUkx9e1KG1lZ +xZBp6TcQVHZzmiD8NKQwNlYD3HBYQThRfLzDRbFbLPil+i9cnczcGDqBrHYLAiuX +cADogAtVxUbH2zeF3BjlIiurW3tVNWPvdnIGDpU9Jq4JtrTO2ABGPUgNJdmpHkHF +VP2+z6cqePeERShky8bqyQ== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -68,7 +68,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -80,7 +80,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6cmfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+yYXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZEZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeYdtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8GA1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IBAQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLvXNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpzbkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJYNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjyz+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQARrAZvqlC+ytq8wqC7ARLBIlMIIDGDCCAgCgAwIBAgIUBvwt4V8CZLs+1AX50R9un62G+W4wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+qm2xTbzgzqnIQFCGXVPNEms/EAPZf7MAWzR59C8hjQFTCvQjFxlxltATu9tFfWujKj9PCE6ZTyqpSSbBtBEFecT5j0tGXE3Nu8+A18Uh4TiyCE30Eya1BPwkMo0RNJBruEOUeiyDcpYGHsSglDY80mn7F72KpM3O1TR55y400+ySjeKT/sBriWMOLGnylv/s1LXOZ8xO5auP0ppe/WOmBwOFxKCdWb9J9q34PWIWDX+fR1/rJjVvAri9u/0mXOP+9FA/ohh/xcsflKXAyDh9j+kTIWx1RTQ2Nhuu4KYV4ZAXhct/r7lEyZPLfNvj0qGSBwWYcFz563pKwtFLtAxjAgMBAAGjQjBAMB0GA1UdDgQWBBTOHI7zMsN8ofbAx5VeQe+jQlshzzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAf+I3qzXslgZbYmPnmgKDyHvM4JKLCdNVCNe+7s5E6YFIUJQPCika2l8e+kdKIfv3+KmkXKSkPY9OoHUpP4ERSbTKJI8G7QwLFhDSU9o6ZTOMoko62Vo7R/O2680jh4NBnJQn/Q+mqBvBV3h10rvH3sH2anrcTcACV8ZA7E9LRpSQ2J8Qebe/Wsrq06UFoOADkRhdejf7CCt9Xvgap/2B7EAaxoqPgxGZWusmrPldtxzzjpIU7v9vxogW4OZWfuK3/yd+1DtuNw0QeOjDym7bfxy3yoC2X+Tqp+YaHaL+lH1vI+w0bfVVckFyUSE4Bg+9kcnbMe3OSCHIssxUptTFUw==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml index 107a118a..1a24ff4a 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-responder-by-key.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFZAoBAKCCBV0wggVZBgkrBgEFBQcwAQEEggVKMIIFRjCBwKIWBBQ7nnoZmhqJ3zMre29INTIQzKLAqRgPMjAyNjEwMzExOTAwMTNaMIGUMIGRMGkwDQYJYIZIAWUDBAIBBQAEIDeIZrkLqw2jsvBbdxmiNHaeHKuaojYH5vL2H5OaxnxoBCC+gAFNfXMPXKAMVqTso9qtMYJWbKWhiAHxeujq27WK7QIUEtP+apS9r5y6gzIiabdnRXiOuCqAABgPMjAyNjEwMzExOTAwMTNaoBEYDzIwMzYxMDI4MTkwMDEzWjANBgkqhkiG9w0BAQsFAAOCAQEAuCAb8cYDyw/c8rq4W2MkNsyM2Ev4p97VP949hIpnQtu9s3Ol9Kk3smkdqDdN+VOFh440J4g45T/1wV8TuUXu2Yc4aUN5NCuGxyEqJmtaaFNNIgwQuoQaMj3SL2ak5NjqSSOn6OkXsjwLA37gVs/K8p/qecvirpSKwiiEgfKu2sdjl4SXC/2dRY5muhcwmeYu+EgN/kFBrQys30hQyriQxZP/PyfKRWHGIn6v+d0kDdS6cLdBsOUT1TAm7K8q/IhbgslJQ5xfxSMh0gLu8+RNm2dy612jXX5yaGSIc3yY2fmJ+xBcbjh23u1OY+KXUGwJk39xdsgvUO31XoRMjqHataCCA2swggNnMIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFZAoBAKCCBV0wggVZBgkrBgEFBQcwAQEEggVKMIIFRjCBwKIWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOhgPMjAyNjEwMzEyMjAxNDJaMIGUMIGRMGkwDQYJYIZIAWUDBAIBBQAEIDeIZrkLqw2jsvBbdxmiNHaeHKuaojYH5vL2H5OaxnxoBCARqzXzoZacZhMXPtgBYJPG/tlRcltwPvA7EUzdcPcIEgIUI+mhZon5gm3pxR9NmgJFfu0us8eAABgPMjAyNjEwMzEyMjAxNDJaoBEYDzIwMzYxMDI4MjIwMTQyWjANBgkqhkiG9w0BAQsFAAOCAQEAImJ5XeE9+WlFdrE+3/oxTqcxxf4KjzNwH0BO1oMtl3oV0n8cbTQpkBVwNi3NTthITCPRd80sHG0FCzyrbO8kRCixVNBWSkL92Z04vr1QUT5YKRt2bBd7Htlzh4DLpi0ptTIeoM5yu39Uqb7xkRQm9edbXdDFK9xYBV1RVw3mEJljtb8r4YXYWWus4ksKpCcMG44HfyGv936CbiZmMy7WM1R1Hl3ZJgtUWCttnBuqsn2A+FdG/akqU510FEHODiLw5NsPCxlgCjwqfpMlkmTnj/2c/D9JN3mR9c77cGCuo3BjZf4IZUeJfy1d9YMr7Yik5c/6OW1Nbjb//bw2PZeESaCCA2swggNnMIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml index 29302cc5..279c4f94 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-delta.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6cmfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+yYXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZEZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeYdtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8GA1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IBAQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLvXNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpzbkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJYNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjyz+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQARrAZvqlC+ytq8wqC7ARLBIlMIIDGDCCAgCgAwIBAgIUBvwt4V8CZLs+1AX50R9un62G+W4wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+qm2xTbzgzqnIQFCGXVPNEms/EAPZf7MAWzR59C8hjQFTCvQjFxlxltATu9tFfWujKj9PCE6ZTyqpSSbBtBEFecT5j0tGXE3Nu8+A18Uh4TiyCE30Eya1BPwkMo0RNJBruEOUeiyDcpYGHsSglDY80mn7F72KpM3O1TR55y400+ySjeKT/sBriWMOLGnylv/s1LXOZ8xO5auP0ppe/WOmBwOFxKCdWb9J9q34PWIWDX+fR1/rJjVvAri9u/0mXOP+9FA/ohh/xcsflKXAyDh9j+kTIWx1RTQ2Nhuu4KYV4ZAXhct/r7lEyZPLfNvj0qGSBwWYcFz563pKwtFLtAxjAgMBAAGjQjBAMB0GA1UdDgQWBBTOHI7zMsN8ofbAx5VeQe+jQlshzzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAf+I3qzXslgZbYmPnmgKDyHvM4JKLCdNVCNe+7s5E6YFIUJQPCika2l8e+kdKIfv3+KmkXKSkPY9OoHUpP4ERSbTKJI8G7QwLFhDSU9o6ZTOMoko62Vo7R/O2680jh4NBnJQn/Q+mqBvBV3h10rvH3sH2anrcTcACV8ZA7E9LRpSQ2J8Qebe/Wsrq06UFoOADkRhdejf7CCt9Xvgap/2B7EAaxoqPgxGZWusmrPldtxzzjpIU7v9vxogW4OZWfuK3/yd+1DtuNw0QeOjDym7bfxy3yoC2X+Tqp+YaHaL+lH1vI+w0bfVVckFyUSE4Bg+9kcnbMe3OSCHIssxUptTFUw==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBrzCBmAIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgPjA8MB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMA0GA1UdGwEB/wQDAgEBMAoGA1UdFAQDAgECMA0GCSqGSIb3DQEBCwUAA4IBAQBYrGeJFcHEyEm1rU6h8LUt/k84nSlLz4Fl8fN3AmGSDl5kxsnuynFxpN55NWDRFeTK7bQCrBXcj4Qt4QTO02YnRnUtBt/5t/Wgsg7jfCjkcl21CDXPVPcjjXf14h3JzoAVntOHtqCZ1p5COsUtkdRS3irIUc8YdAIobYb4/JqHpNpO0j+c9X9xqMb1hw+LU+Qn2f43VhStiXEbDfArhIJgDb26iNuka/8RxAFDvse2tsXQ7nbU85LuDOd3xP5czLu/7F5jMpimNstbFHgWnhzv2WgegdZERAX6uxrhYFIjGmpOz28ehOgC/wslYH6R/B0TAwvanr/9qWJTvCnM6l86MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBrzCBmAIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0M1oXDTM2MTAyODIyMDE0M1qgPjA8MB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMA0GA1UdGwEB/wQDAgEBMAoGA1UdFAQDAgECMA0GCSqGSIb3DQEBCwUAA4IBAQB+l6nNbxHGJcRpSzngZruKgNQ5SjF3zdliWHlg7JTrxcADdwJCkR8V5V8sSAbRJ64WVPYz5AI2KVqBN0NZx1OC4q64FPViRPBs/PLDGd+Aj+Bug/NGupN9ZI/g9JXdHibrWDRGwVw0YuV1PMmgROZD26gLYxa2wGIwqkSUEp6/7hcxTa9XxQLnmRSdI/dQvgoMgJ6Amz0dhmnAsrPJMK1OvCNzfixY0DRsndvmIB9iqVz2tevH/lW776roOiWMYQdPg4z4kG3E7QFkKorJIIAwBBNSsxrXqPcSbruILa/wKnqHIbCPN6VxrKzP7wQM7BtsVKuKqdg2On8kadptqa6GMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml index 389700be..77dda211 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-material-misplaced.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + MIIGAAYJKoZIhvcNAQcCoIIF8TCCBe0CAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgyfi37k1GRUWbS4GcSfzR44KrayBlnPmF7g9QYJkXeVgCAQIYDzIwMjYxMDMxMjIwMTQyWjADAgEBoIIDUzCCA08wggI3oAMCAQICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCMxITAfBgNVBAMMGHhtbC1zZWMgWEFkRVMgTGV2ZWxzIFRTQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK0bg9V9Mjhz2DVyWdkiFN081doIZF+stQJhHXwguHB+YEIGdd/P+Darag2+s+qqrSZk5PbmW1I7/Eh8wqyJDcL/Scd3lh6Fnlvb9Ew3v/fPJEaJ5A4tm/ZBwMLD3mxnVbzrgIGz1FYCTq/vBLnXROrOa26wdpDOF/iSRA9HCxb3OIrQhBDt9rqxNGWiwniO1JlTI2VVwind7j5RI6FcBN+kW2OKIeCv+KV68mI/AjfmucxTsMlm+kWyc6jksyplFeqKdD3DJIEAHRVEwvGoSh0ttw9kAuvIrBQEC984APeGYbYKve6uXRhTtolRt0GAEkTMqL3nBFV6DhZCHl1sfCsCAwEAAaN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFDAptmIEho8RaibTU/pRVVSKMHAKMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMA0GCSqGSIb3DQEBCwUAA4IBAQAaL2vX7reLiycO4Ad658XQ2jo3EWp/TkVIKcd5nzm7Cf5mAeKUXn/zO1KwVkzH6XXaQD6P8mI1gE9XDOK+YlmjTl1U42LGBQzYpGaJwnHyt4iZTYPDPH3KgNyWxWg5dTePwA18XxFU56/GVU6YGrt38Kbzjkbi7oUX1GLckyPv4Tl0LwVMWJ8nraRVVWwzmLLVHI3tUnq9aOG/RCTb8kXnXC//W9jdNdpNyDtqziE6m73eHegE66Ac8cgRMvheJW++dmdVZl+gQKZfDywfh7lruvA1iHbm/B0K37oxZd9XLFiqHccdKhHgTyDDXX/RGDwn9sDi+2TpGqNEO3fdwuyhMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMjIwMTQyWjAvBgkqhkiG9w0BCQQxIgQgG6Hu8WW4ING2JTBWRKFZgSoqmB2AT6EdNNZZS+1vO8swNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUr7VT9OiNbhvo6Ni4VbpXB8cztwTcL22CkRv8prqKw0wDQYJKoZIhvcNAQEBBQAEggEAnMCHP5hfhEY6vrK90zCs0x6gsZhtMM7Kn9lbrrYBzlk8fGBxdHVqn81VbTYaWZc25o1fj4yZennVCf8+NKHpeSFwhDmL1ntONjR22unzeXClBGlbA1Dqqw9D/P2HZy+TPKbbuSuT0VzBbhnlqFrqx4MnSApz4NUYeM3SYnwm/hbhzSDZULdIcbeWQqx9fiE2wy+/X+D0Qb+UmXYLpSlJN7hMTMye4cwZbQsKklsEBqsYnVuOamhhJKvEaL0yCbOqOJreNrgUZgcR8mIW+iOT93Z2gfI9wzUpOrsrfB9M3RP6wKbZZWxMBvFIwM5uiDmVACJY963POXH+EXDjzewUhw==MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1MaCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEnve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJTEoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIfbToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmhLZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8GA1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IBAQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5aXwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/JuPKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6MLRhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/RIK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyifVL7mBUrNNo985oDyR+xacQV7MIIDGDCCAgCgAwIBAgIUdKkoW19XYcrWuD6fg5YI3Mr67PowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+axd1136T+c2X41gOfkSBUz3jIZ6omZPYN7VCtdu5HJT+5MLK2MD6xAe/TpUqDAraVYTHAJILjd/7mh4Lfsi3fnMvqelftFI8A6O+x/aiM69YHKuBnJBIvRllVluw0I+yiliKjeINw4GqUa3TKezs7NkV1R794PzA+/EwW3L5X0M1YNwdUVjI/v9knc7a1H32xXlIRMBpvVb80j6/u4pOS5Mc/j0vTRjl7qzBzPFsYrVPvIs+ZVpVh/Qxko+N1q96AdVj2hkosQb4iMXV6WaHXijg7Gt8e5Y2+12r0r/q45hcCSamdh9QKG6MeU0xMyItZoa//HX3/tXr3Da41ib/AgMBAAGjQjBAMB0GA1UdDgQWBBQUBPmNKWYSP62c8mUyPtevHJ+pxzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAZnFH4dgvrQyyaX0Lcic9oEDB1WB+e7zYYkvyIyiuP+LSeGoAK0AvrcpckGqcHv9xgpLRyhWOme8Rj5dMo4bAcEGy+zaogUelJzafcDzLQg1T5lLMOy0Nx7eDSfrwNr96tVafZfXw8PfBz2XXgcZ2tfJf+Xz6zRnA3aOWzyql5xHAMKjUVWeyXxI8XJ/2oyrD2SwRQ7k6nvzWkQPV4SUglsAvmH4j5bbGhAis6zCYeCEPL/8By5VvndeMBzHhGHH1sAp2JjvStScqw0Y1qfLn4ezb53OQ/rhaYgxk4FZ9bqbso1XI5KjHkLrihPL2RrAlF0X6Tc1lUJzoeBe8qtgtnA==MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU= diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml index 39309122..71dd71c8 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-tsa-revoked.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxNFoXDTM2MTAyODE5MDAxNFowJzAlAhQuLzvOU0+AV+t/Nr3QPSrE54WrrhcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBAKJNtyhIIJNuocMg7Q/pGov8lDhebX4Pmran+jNrCG/nClMZP6EZs7LBY9KKiEoZ+SSnQ9N+TrylBwLMTXNX9al27/GL6LkiuX6bK4CwSky8C/YitHeFBVPYBxuBh96SwdaeuKHBEBWXAQwSKxJ5RXiCYWCAsPezbst6NAuea1rv5twGp1CmKUmmejLfXIkzv55jAPnymsGyRPO98aaMO5sSrma9ccqqJ9eJzVQR25v6ImjRPElkqzd/OwWpb+x2kSl8MdZB4gGFlP+PpQtZTrpCZtSRgNGPje2li+3A1rj72bwl9EkbSjIPk8jYjU8u9HR4HOVtTGq+FwtvsAkepfQ=MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIByTCBsgIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0NFoXDTM2MTAyODIyMDE0NFowJzAlAhRF7I9GhfhAin+wDnLswsAZ0aQZFhcNMjYxMDAxMDAwMDAwWqAvMC0wHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwCgYDVR0UBAMCAQEwDQYJKoZIhvcNAQELBQADggEBAGYj1svcs1cOjlPnrJxYGdR6JJ8BZpxrGr9sCwUWof7siKpc4LRaMG1uLCdt329Tivm3DWgvvsfzoOOx3e0oJJj2c0S108sOant+0txEFA5jVb9Mn0oKPZqvzEPL9kXJaXCpyZjg5sYe4FxNEtVjJGdYsVEmiIZj9MBbhFG7dyJETzcdgqLxUQs2PnCy/iKgqj82JNZoegC4i3xrSaw3jq1Ykmz48Hx7fGpWW0Trmd7BybxHWo1/PGe03+AO6AFbtkKL6zfixG8fLiQ/o14SyTgyjK/jVnQSj87ERuDadanSLXHV77olLcku2B3Z85Wl+RKSdSf63hk+4hwo1Iv+UZ4=MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-responder.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-responder.xml new file mode 100644 index 00000000..0235d6dd --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-responder.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= + + + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= + +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 + + + + + + + 2026-10-18T12:00:00Z + + + + + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= + + + + + + + text/xml + + + + + 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MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIICEAoBAKCCAgkwggIFBgkrBgEFBQcwAQEEggH2MIIB8jCB26ExMC8xLTArBgNVBAMMJHhtbC1zZWMgWEFkRVMgTGV2ZWxzIENvbmZpZ3VyZWQgT0NTUBgPMjAyNjEwMzEyMjAxNDNaMIGUMIGRMGkwDQYJYIZIAWUDBAIBBQAEIDeIZrkLqw2jsvBbdxmiNHaeHKuaojYH5vL2H5OaxnxoBCARqzXzoZacZhMXPtgBYJPG/tlRcltwPvA7EUzdcPcIEgIUI+mhZon5gm3pxR9NmgJFfu0us8eAABgPMjAyNjEwMzEyMjAxNDNaoBEYDzIwMzYxMDI4MjIwMTQzWjANBgkqhkiG9w0BAQsFAAOCAQEAZewKqP3XD8k7OQ0RksnfaTb5mX7ZObnLwOzCrpbJLZesQrDjuhPRnQLEiajnFB7kHZo25kOfgNOuPVfMAEikPEeQT2fmL/LSA347lL4bWgoOScq0Vbfm4qQ9n+sP+lCkh9XR/fo/i2/hrKGg/1BkoeujKT8RHbDVinnsUr/hIVaumUXZHeI/9EQooEXSxtX6tmGkYkmDrXIVsjtLvB0ztPztVlrZc+nLYDrXU0BQGz9THS+dcVCYntUGvVdu/9b5+sn6AOHA+YriwBK+bmixjOBoELKyfFRQn1S/fbbTdenYU5I7xZtq2CXHt8cgtAgQCOb7p6CsAWokd7PB6xO/sg==MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIICEAoBAKCCAgkwggIFBgkrBgEFBQcwAQEEggH2MIIB8jCB26ExMC8xLTArBgNVBAMMJHhtbC1zZWMgWEFkRVMgTGV2ZWxzIENvbmZpZ3VyZWQgT0NTUBgPMjAyNjEwMzEyMjAxNDNaMIGUMIGRMGkwDQYJYIZIAWUDBAIBBQAEIDeIZrkLqw2jsvBbdxmiNHaeHKuaojYH5vL2H5OaxnxoBCARqzXzoZacZhMXPtgBYJPG/tlRcltwPvA7EUzdcPcIEgIUReyPRoX4QIp/sA5y7MLAGdGkGRaAABgPMjAyNjEwMzEyMjAxNDNaoBEYDzIwMzYxMDI4MjIwMTQzWjANBgkqhkiG9w0BAQsFAAOCAQEAE7nancJjSnLhzsb6amnmFlMeVT3obaz0nclPVJnPgcAYlys1UbTn2/COhGbL+1il8gZzMnj8ypS40LLNjeu/MJlq3nqYtHQuaSuA2J0Op3/zcuQNW0ki71coRctQ3rwKImf4apzSRv3czJ+clDpYcgrTL73Eyvgk2m0Orht4PakgMd+hLlAQNgEGJTlgc5TcE9BfwxnbwUEsdIKgmyBciNfESN1ZBXeWKAVK9uLLxm+AIhnbe6bneC2dEbRoFCqk6gkz4sNDFQ+LIssa7jiX/yUUgv4GjEy5DagiNtWDGxRex2oKUeMVQgqoZvWLmJYkpU+BCwNC+YyuV1l+uru5lQ== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-token.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-token.xml new file mode 100644 index 00000000..d0bdb0de --- /dev/null +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt-uncertified-token.xml @@ -0,0 +1,90 @@ + +Levels payload + + + + + + + + + + + TOb6p9GMYQ8nwjtSxSdXHSRCegtTkZn+LRv8PIX9RUc= + + + + + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= + + + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL +BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 +MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY +QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= + +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL +BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx +MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk +RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 + + + + + + + 2026-10-18T12:00:00Z + + + + + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= + + + + + + + text/xml + + + + + MIICqQYJKoZIhvcNAQcCoIICmjCCApYCAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgyfi37k1GRUWbS4GcSfzR44KrayBlnPmF7g9QYJkXeVgCAQIYDzIwMjYxMDMxMjIwMTQzWjADAgEBMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMjIwMTQzWjAvBgkqhkiG9w0BCQQxIgQgbRKx9AyTpvtiKyGX8yckoEQh7Sc2O/FiNhsO93l/Zb8wNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUr7VT9OiNbhvo6Ni4VbpXB8cztwTcL22CkRv8prqKw0wDQYJKoZIhvcNAQEBBQAEggEAWpM29oZrwEPIAXh4on70bP/90dij4ffrzz0DkObPm5YLl2Ty3OI8dReQcV6qR5UJJV/IGvHd0ep7ZGjrQib/L30pCil/wCGEbzBc29bD5M3+XwUEvupBwHt33/KU1Z2uzLDWQThl5eLEjwfAx8+C6KulIRhIJuhtojiV5KUGp7w4TvmgJdj+dgfLMETSAitvXhP34ZRM9lDCOBv7AP5Jiq4smo2u88E1l41PcDQZ1Ecz0uF3X8VRhHn2ZGzUb7Sj3RvRPx5RZgrXZyh/nMIsQi5QDetn2iY9v4j331CTGAXOl05rO4XdI1v5+zpJzB0mRQ2dsnZG7+tk0iVkfBj/Qg==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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1MaCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEnve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJTEoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIfbToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmhLZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8GA1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IBAQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5aXwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/JuPKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6MLRhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/RIK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyifVL7mBUrNNo985oDyR+xacQV7MIIDGDCCAgCgAwIBAgIUdKkoW19XYcrWuD6fg5YI3Mr67PowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+axd1136T+c2X41gOfkSBUz3jIZ6omZPYN7VCtdu5HJT+5MLK2MD6xAe/TpUqDAraVYTHAJILjd/7mh4Lfsi3fnMvqelftFI8A6O+x/aiM69YHKuBnJBIvRllVluw0I+yiliKjeINw4GqUa3TKezs7NkV1R794PzA+/EwW3L5X0M1YNwdUVjI/v9knc7a1H32xXlIRMBpvVb80j6/u4pOS5Mc/j0vTRjl7qzBzPFsYrVPvIs+ZVpVh/Qxko+N1q96AdVj2hkosQb4iMXV6WaHXijg7Gt8e5Y2+12r0r/q45hcCSamdh9QKG6MeU0xMyItZoa//HX3/tXr3Da41ib/AgMBAAGjQjBAMB0GA1UdDgQWBBQUBPmNKWYSP62c8mUyPtevHJ+pxzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAZnFH4dgvrQyyaX0Lcic9oEDB1WB+e7zYYkvyIyiuP+LSeGoAK0AvrcpckGqcHv9xgpLRyhWOme8Rj5dMo4bAcEGy+zaogUelJzafcDzLQg1T5lLMOy0Nx7eDSfrwNr96tVafZfXw8PfBz2XXgcZ2tfJf+Xz6zRnA3aOWzyql5xHAMKjUVWeyXxI8XJ/2oyrD2SwRQ7k6nvzWkQPV4SUglsAvmH4j5bbGhAis6zCYeCEPL/8By5VvndeMBzHhGHH1sAp2JjvStScqw0Y1qfLn4ezb53OQ/rhaYgxk4FZ9bqbso1XI5KjHkLrihPL2RrAlF0X6Tc1lUJzoeBe8qtgtnA==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== + + + diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml index 81da6dad..5e1724a2 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lt.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1MaCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEnve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJTEoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIfbToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmhLZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8GA1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IBAQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5aXwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/JuPKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6MLRhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/RIK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyifVL7mBUrNNo985oDyR+xacQV7MIIDGDCCAgCgAwIBAgIUdKkoW19XYcrWuD6fg5YI3Mr67PowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+axd1136T+c2X41gOfkSBUz3jIZ6omZPYN7VCtdu5HJT+5MLK2MD6xAe/TpUqDAraVYTHAJILjd/7mh4Lfsi3fnMvqelftFI8A6O+x/aiM69YHKuBnJBIvRllVluw0I+yiliKjeINw4GqUa3TKezs7NkV1R794PzA+/EwW3L5X0M1YNwdUVjI/v9knc7a1H32xXlIRMBpvVb80j6/u4pOS5Mc/j0vTRjl7qzBzPFsYrVPvIs+ZVpVh/Qxko+N1q96AdVj2hkosQb4iMXV6WaHXijg7Gt8e5Y2+12r0r/q45hcCSamdh9QKG6MeU0xMyItZoa//HX3/tXr3Da41ib/AgMBAAGjQjBAMB0GA1UdDgQWBBQUBPmNKWYSP62c8mUyPtevHJ+pxzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAZnFH4dgvrQyyaX0Lcic9oEDB1WB+e7zYYkvyIyiuP+LSeGoAK0AvrcpckGqcHv9xgpLRyhWOme8Rj5dMo4bAcEGy+zaogUelJzafcDzLQg1T5lLMOy0Nx7eDSfrwNr96tVafZfXw8PfBz2XXgcZ2tfJf+Xz6zRnA3aOWzyql5xHAMKjUVWeyXxI8XJ/2oyrD2SwRQ7k6nvzWkQPV4SUglsAvmH4j5bbGhAis6zCYeCEPL/8By5VvndeMBzHhGHH1sAp2JjvStScqw0Y1qfLn4ezb53OQ/rhaYgxk4FZ9bqbso1XI5KjHkLrihPL2RrAlF0X6Tc1lUJzoeBe8qtgtnA==MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml index afca8d5b..860c1c2f 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed-digests.xml @@ -12,52 +12,52 @@ - t49QRjv1IEbVJSwLcyU80GKclR8apTuH9axSCxHXTHM= + YS34CpH599lpNAJ4EUWNb5k6kEgI4JNXE764qAf3qeE= - e02s3B0M07f4iK6pyUuhmPHnX8dTBuFfEMPli5HTULP5EZpUD/0bE0vpeoVc6r5e -9O5fj9X/q4cUj2SLmRmUnKztqyS8fnkq/JkP5YQ+BIidDzwCQOZsZkO3s4e+fHfe -bon+MeIp9d3ikylOZGU6xrTxdvq6B8CcXIEFQp9aOJSkKQzl6JQzj0PpLcLg4R6e -nun3DyRz+Rq/wvgwN/lRrCkctbpmtYzibY+gc5+dLtivNGpyOZIN1VKH3NQM569u -aJQcXj4nlgvshxUUHtBBG+ocHr/8KuGVlFwgaGwhvqsPdBR4ORSorSAhDXRLVGYY -0hvf0A5rGK9lcx3bTsKwPg== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + AYtzl9dTqK8D4ysd7t4hJcN1TjZdXkTkfbywN1jWy2wf2rAa4tMK6SQUWAloMPHF +hSwhFP69zcNrSkwf4La8qtGK1k1cnhRB5JvwawtdPMSWpgKhwcZPAp4l6PNSNr8I +lxKtM5ZlQwgE/W+klXraZoILpMPis7NMaymmu/sCvSTU5RUk2kEs7yJt/lArBDA+ +1k004+Q3xtkSmdNBqzKwd1tOjgFAzA4vy9YqAFRojlSzji+bJIHhUTtNeiguD+7d +OELa4ZJZtiKORo/3DrueSvLoBFp4Z0SjSJfAOLjm6xKRhw93ZfEpz+NHqGqiOKgj +Yh3ZOi0n053QVwTEmuYbBw== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 LruzvJ9DZFMg52TN27sjEyvVN/+8aupMC7iyaAmRzDI= @@ -69,7 +69,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -81,7 +81,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - MIIGAAYJKoZIhvcNAQcCoIIF8TCCBe0CAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgsfjagFakm7wIiKuW9VQRdn/+S7XQTutnr2ItyFJFk7gCAQIYDzIwMjYxMDMxMTkwMDEzWjADAgEBoIIDUzCCA08wggI3oAMCAQICFC4vO85TT4BX6382vdA9KsTnhauuMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCMxITAfBgNVBAMMGHhtbC1zZWMgWEFkRVMgTGV2ZWxzIFRTQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ5lcp6jEjevARbPMn130qbDW7xdm0WKLgNzc/++nx5rITeDYKO+iNjBKBSloDoHBwseuN6Cf7sULAmPeeooFkU/Jne6A1z1iWfmqKJhvW0Qo28e17lB8zJfnwXSlkDAbr/Wau8xjKQYVFDebdSSOmtgvyDz1W/rTPss7CSFlLxItx0PAx4US9pv2UPKoZxbiJGjah3gDx64DhmUMkvsYW/A0HWclU9Qe4ThuoclIIiFIohEobzXcgxiz37CTqyHQR3i8cAL2fmvABVlBfxv/XjqbmJd6B3due/hXA4iA0tkhScHXrZl9JF5yum9oTyFVG9yi3Okr/JEt7P/7xX/GpUCAwEAAaN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFKu/njCfigLBibaZFqEvnVrTseoEMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMA0GCSqGSIb3DQEBCwUAA4IBAQAZKeN+eE7IHI+B7QF0GdDqKVDvBlmjrb5/dO3gthoY2j/ulruBDmkpCF0o4GZg5KDbRLo22BV4V6Vq8cYIN2XYCj/ssLV9r8rnQuPi9oeu5mQNXncekxTO+IDdLsQIZNeN4QKXdf0zatKUfjIyBWebBOxAdOl1OE/pr4CEHUkJJ2bpKyk/YJy8P+o66u/DCoGxAnf1OVW1Y7va27Gms5dM+PRgSK9vsQtCT+YN/l6jkTYWj/uvkgDJE3oDGCl4Ea4+1gbfdWuzQcY1kDAGVC/ul2GjXUCweJ4iceRnK/X2R8OEiGW2segTWFNYg+s2z31qtgsoHUJE+ZFhvGb3cc/HMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFC4vO85TT4BX6382vdA9KsTnhauuMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMTkwMDEzWjAvBgkqhkiG9w0BCQQxIgQg3FRIy1JYUdggsYpP9/yEfopn6Bs8sIKroAhyU1vZF1UwNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUOP4nhD0v9FR++FXdpq+OQ7CdFF31MrUcQjPBt9Gl3IwDQYJKoZIhvcNAQEBBQAEggEAUfhG18emFDunDHlW80nNzsvD55qWWms05y/rBybW3wSI80+9NxgLFNBJPge1o5C6DR6YqyzGm7Q32G66kE4+9eSCqmDMrlNRYGHd62QG+UUv5vcMveGECpUlanjUY/Im108GXHcpXIeS62AotF3qpen2fev1RfTJfZ8Ttkvv3xwahkwjHag/LFF87OfCg+OeogA0Xpc6L54+czl7v+hhoMRDM4UsmyVc0XMgebXJTPDMa/2yO77jAUvSpOv2Ti/3S3SmECM+GYaljYlQhKR9n2Whal8YvtD5LtOeEKxghvnlO9LCt303CDlkz9rq0y/ZjkSzDrqGgLMCrflbJKpBcw==MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6cmfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+yYXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZEZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeYdtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8GA1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IBAQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLvXNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpzbkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJYNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjyz+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQARrAZvqlC+ytq8wqC7ARLBIlMIIDGDCCAgCgAwIBAgIUBvwt4V8CZLs+1AX50R9un62G+W4wDQYJKoZIhvcNAQELBQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC+qm2xTbzgzqnIQFCGXVPNEms/EAPZf7MAWzR59C8hjQFTCvQjFxlxltATu9tFfWujKj9PCE6ZTyqpSSbBtBEFecT5j0tGXE3Nu8+A18Uh4TiyCE30Eya1BPwkMo0RNJBruEOUeiyDcpYGHsSglDY80mn7F72KpM3O1TR55y400+ySjeKT/sBriWMOLGnylv/s1LXOZ8xO5auP0ppe/WOmBwOFxKCdWb9J9q34PWIWDX+fR1/rJjVvAri9u/0mXOP+9FA/ohh/xcsflKXAyDh9j+kTIWx1RTQ2Nhuu4KYV4ZAXhct/r7lEyZPLfNvj0qGSBwWYcFz563pKwtFLtAxjAgMBAAGjQjBAMB0GA1UdDgQWBBTOHI7zMsN8ofbAx5VeQe+jQlshzzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAQEAf+I3qzXslgZbYmPnmgKDyHvM4JKLCdNVCNe+7s5E6YFIUJQPCika2l8e+kdKIfv3+KmkXKSkPY9OoHUpP4ERSbTKJI8G7QwLFhDSU9o6ZTOMoko62Vo7R/O2680jh4NBnJQn/Q+mqBvBV3h10rvH3sH2anrcTcACV8ZA7E9LRpSQ2J8Qebe/Wsrq06UFoOADkRhdejf7CCt9Xvgap/2B7EAaxoqPgxGZWusmrPldtxzzjpIU7v9vxogW4OZWfuK3/yd+1DtuNw0QeOjDym7bfxy3yoC2X+Tqp+YaHaL+lH1vI+w0bfVVckFyUSE4Bg+9kcnbMe3OSCHIssxUptTFUw==MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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ihMagMmK8hAzA+28fMYKxTyNDPKqnQINKF39EuClVKR+BQQOTRF5SQ9KKu4wml22Lttwu29G4hYY2bMA/B3Cdw==TKmSHV1TEehk3y8Qcw/0cSFLNES710AvwKxhj/ELat4UXppZWdF0jyPOB5saB0axmyp6aipPTiWrTSE4JzG7UQ== + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==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ihMagMmK8hAzA+28fMYKxTyNDPKqnQINKF39EuClVKR+BQQOTRF5SQ9KKu4wml22Lttwu29G4hYY2bMA/B3Cdw==TKmSHV1TEehk3y8Qcw/0cSFLNES710AvwKxhj/ELat4UXppZWdF0jyPOB5saB0axmyp6aipPTiWrTSE4JzG7UQ== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml index dd54a7ab..08e7df3e 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta-renewed.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIGAAYJKoZIhvcNAQcCoIIF8TCCBe0CAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgx5t0g7rJGTE1y8mnW1NsDWBDL4P5fZGdbrDw0sgd1wECAQIYDzIwMjYxMDMxMjIwMTQ0WjADAgEBoIIDUzCCA08wggI3oAMCAQICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCMxITAfBgNVBAMMGHhtbC1zZWMgWEFkRVMgTGV2ZWxzIFRTQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK0bg9V9Mjhz2DVyWdkiFN081doIZF+stQJhHXwguHB+YEIGdd/P+Darag2+s+qqrSZk5PbmW1I7/Eh8wqyJDcL/Scd3lh6Fnlvb9Ew3v/fPJEaJ5A4tm/ZBwMLD3mxnVbzrgIGz1FYCTq/vBLnXROrOa26wdpDOF/iSRA9HCxb3OIrQhBDt9rqxNGWiwniO1JlTI2VVwind7j5RI6FcBN+kW2OKIeCv+KV68mI/AjfmucxTsMlm+kWyc6jksyplFeqKdD3DJIEAHRVEwvGoSh0ttw9kAuvIrBQEC984APeGYbYKve6uXRhTtolRt0GAEkTMqL3nBFV6DhZCHl1sfCsCAwEAAaN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFDAptmIEho8RaibTU/pRVVSKMHAKMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMA0GCSqGSIb3DQEBCwUAA4IBAQAaL2vX7reLiycO4Ad658XQ2jo3EWp/TkVIKcd5nzm7Cf5mAeKUXn/zO1KwVkzH6XXaQD6P8mI1gE9XDOK+YlmjTl1U42LGBQzYpGaJwnHyt4iZTYPDPH3KgNyWxWg5dTePwA18XxFU56/GVU6YGrt38Kbzjkbi7oUX1GLckyPv4Tl0LwVMWJ8nraRVVWwzmLLVHI3tUnq9aOG/RCTb8kXnXC//W9jdNdpNyDtqziE6m73eHegE66Ac8cgRMvheJW++dmdVZl+gQKZfDywfh7lruvA1iHbm/B0K37oxZd9XLFiqHccdKhHgTyDDXX/RGDwn9sDi+2TpGqNEO3fdwuyhMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMjIwMTQ0WjAvBgkqhkiG9w0BCQQxIgQgFlfIlsaUwdG2sDk6cm6sPw9A9Ash3pjN2Rv8V6ovLGkwNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUr7VT9OiNbhvo6Ni4VbpXB8cztwTcL22CkRv8prqKw0wDQYJKoZIhvcNAQEBBQAEggEAJUrqKHZyJcNpp0PwoJhxBq9gUiTX6bhhRwpHKACSIw+k8DNfr6VLOV3/oFO7bDGh3GbrZO2Tds92ewyvPJXXUGkrMH6WHW48gVuvJy88P/nWkONY/D1mItcbPQlnEf9TTX690Ml2rrGFLo9yFTnScYin5tQnvjz/Rd77Vh83o81kwTh4gd3Kl8bdVDYGSbuX1OcgDU/tciS0ypPUxKXWGxVH5CnQeOTSbRgRiAeSDIuYnNZ93wWEUkpoNzB2uIB2sFDlI3ImhphdE10VcHhlhJYv7gZSL88Jsuj9OZJZd7HObN7fOL93VcFAdrDaDyOm018R7ZPqzHPeBlkwQkwkDw==MIIGAAYJKoZIhvcNAQcCoIIF8TCCBe0CAQMxDzANBglghkgBZQMEAgEFADBsBgsqhkiG9w0BCRABBKBdBFswWQIBAQYIKwYBBAHrQgMwMTANBglghkgBZQMEAgEFAAQgPOyU6wMszcHrzCu0sj7EYFe4EYhqhierJJ1GyzamP58CAQIYDzIwMjYxMDMxMjIwMTQ0WjADAgEBoIIDUzCCA08wggI3oAMCAQICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCMxITAfBgNVBAMMGHhtbC1zZWMgWEFkRVMgTGV2ZWxzIFRTQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK0bg9V9Mjhz2DVyWdkiFN081doIZF+stQJhHXwguHB+YEIGdd/P+Darag2+s+qqrSZk5PbmW1I7/Eh8wqyJDcL/Scd3lh6Fnlvb9Ew3v/fPJEaJ5A4tm/ZBwMLD3mxnVbzrgIGz1FYCTq/vBLnXROrOa26wdpDOF/iSRA9HCxb3OIrQhBDt9rqxNGWiwniO1JlTI2VVwind7j5RI6FcBN+kW2OKIeCv+KV68mI/AjfmucxTsMlm+kWyc6jksyplFeqKdD3DJIEAHRVEwvGoSh0ttw9kAuvIrBQEC984APeGYbYKve6uXRhTtolRt0GAEkTMqL3nBFV6DhZCHl1sfCsCAwEAAaN4MHYwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwHQYDVR0OBBYEFDAptmIEho8RaibTU/pRVVSKMHAKMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMA0GCSqGSIb3DQEBCwUAA4IBAQAaL2vX7reLiycO4Ad658XQ2jo3EWp/TkVIKcd5nzm7Cf5mAeKUXn/zO1KwVkzH6XXaQD6P8mI1gE9XDOK+YlmjTl1U42LGBQzYpGaJwnHyt4iZTYPDPH3KgNyWxWg5dTePwA18XxFU56/GVU6YGrt38Kbzjkbi7oUX1GLckyPv4Tl0LwVMWJ8nraRVVWwzmLLVHI3tUnq9aOG/RCTb8kXnXC//W9jdNdpNyDtqziE6m73eHegE66Ac8cgRMvheJW++dmdVZl+gQKZfDywfh7lruvA1iHbm/B0K37oxZd9XLFiqHccdKhHgTyDDXX/RGDwn9sDi+2TpGqNEO3fdwuyhMYICEDCCAgwCAQEwPjAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXICFEXsj0aF+ECKf7AOcuzCwBnRpBkWMA0GCWCGSAFlAwQCAQUAoIGkMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDMxMjIwMTQ0WjAvBgkqhkiG9w0BCQQxIgQg/XTaS0R0N23DGzRLTHtqVz3JmQelvzn7F5Rn3M8FL4AwNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQgUr7VT9OiNbhvo6Ni4VbpXB8cztwTcL22CkRv8prqKw0wDQYJKoZIhvcNAQEBBQAEggEAjI2lLfsHIzAXrpSLKddKU6bzdS1tWvnuamhxxc1PsAApn67bzO8dDCrfg/hsMipwNfRYIod05PnAsvX3JFvnKFkJi3qrxaiPUNXGizN2zC0olOwWVZykm2STEY6j5RZUm2v+b4FcyDPBtsnemU/McNqlrvIqSmqc7LEMn7iUytdNN6M53wXfc9w6kVrFLaGbshjp8sGnwSyUbZ3f1CdbFPQXQRbUzkRrWZwDLHPHmJxtQWPwRuSSIACXJzNTH0Qi7lQ8LZLpIXfmZNGZKMftTuR7bTlvAaBVTyrRu42+kN76R9GYtmsxDuXA+XDRXYgL6hTc0fjKPXgqL97HM3TEng== diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml index 7bc5e3ca..d920feda 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-lta.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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MIIDYzCCAkugAwIBAgIUcl5UbBHvhAKnThH50N257D6OVPswDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMblt+Glcmu1w/O8bS3Ufmcc/tmKrzwcLlZvKFBLHNj8+IDG1G+jMNymKKqfX7hEKBcAejO6FxRgWb8e+bWZxC/aO43qcJU/1nd9HXP8WeWUDZWTm5wniyfsag3lx5evlEm283NMkJ1WltjnbHIf/RAcLHKo5NNFTJaM2zOpEolWz/7GrsSHMf9w5/JXrV07uXmVMClLMW2ng5LLm/euu/QylRFbgoQr8vkaMkMBPSy5Y0faYRBqqwBKUMxoShDwy39gKp6tGZhG+KuYX2iHxYM4L5ZDpM2u/5jlfxze9gJ1aDPr76dKZ16B+x8WRNcmt5X6ZAj2Bj/8SWjOABMKvNsCAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQ7nnoZmhqJ3zMre29INTIQzKLAqTAfBgNVHSMEGDAWgBQAM0MrqBue7vYn1TrFGP2UOkgxpzANBgkqhkiG9w0BAQsFAAOCAQEAnCtljBZINNH6uQgI3UTeNUwVD4COCVPd3WveX6bcne6uzomssiXgCKxYhmHT+/s8iB23q5zHUElMkOtOE5yYKymm5CBtWjZgvmLvhi8KVfY04c2CtTRGGPhj05bzRsDsAWIQJtrgASOW6ZPhfemYwJTCiQkgBAjYvCCB0pzUq6l/RwAHkfkotLTMWVGF5sp/dLVFjeRAf/zQayWkGTVQfkFVcd3RCrTDF+NqM9yLwCFrKR2/Pvh6+U3lT9qKKX49qKVIaSytg0jYAbuio1jUKg/jQRfxg5mykS1UP/S9aMjS4lE3awCbjhHILZTacJGEuXa1Q++nRXGzLZAfWTkEew==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMTkwMDEzWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgvoABTX1zD1ygDFak7KParTGCVmyloYgB8Xro6tu1iu0CFBLT/mqUva+cuoMyImm3Z0V4jrgqgAAYDzIwMjYxMDMxMTkwMDEzWqARGA8yMDM2MTAyODE5MDAxM1owDQYJKoZIhvcNAQELBQADggEBAKqgH/G742752+ewSRMdsOz08kMh6IZxj9moy+8RDgYM2fTX/j944e3cYy7LNn++/lggXsX6ePz5Ci0XpccGZKNg5UINHgL+xy6TvTZPhp0U1AnEftUX69AzMmCYme5om4Pg1AX/8pwuhRLeLHpGRUrGg29d3QDCLiBQGVo3UTBhxVRTc9IZwXO3qMgLgF7o1c7gTmGl3Sk+XuOtFZWToIPZ7RtQSg/CZeunklESdkQ1AHot0h27/Qg9FVKXOLjmFjx4LcM2pJPMVUz8ObUJsuRG/PAL6+Asav5CkV/GnXeKJuBZNZPxrRQkte+DxT4wvVTjHxihlQcJIDsI92GlEqCgggNrMIIDZzCCA2MwggJLoAMCAQICFHJeVGwR74QCp04R+dDduew+jlT7MA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDG5bfhpXJrtcPzvG0t1H5nHP7Ziq88HC5WbyhQSxzY/PiAxtRvozDcpiiqn1+4RCgXAHozuhcUYFm/Hvm1mcQv2juN6nCVP9Z3fR1z/FnllA2Vk5ucJ4sn7GoN5ceXr5RJtvNzTJCdVpbY52xyH/0QHCxyqOTTRUyWjNszqRKJVs/+xq7EhzH/cOfyV61dO7l5lTApSzFtp4OSy5v3rrv0MpURW4KEK/L5GjJDAT0suWNH2mEQaqsASlDMaEoQ8Mt/YCqerRmYRvirmF9oh8WDOC+WQ6TNrv+Y5X8c3vYCdWgz6++nSmdegfsfFkTXJreV+mQI9gY//ElozgATCrzbAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUO556GZoaid8zK3tvSDUyEMyiwKkwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAJwrZYwWSDTR+rkICN1E3jVMFQ+AjglT3d1r3l+m3J3urs6JrLIl4AisWIZh0/v7PIgdt6ucx1BJTJDrThOcmCsppuQgbVo2YL5i74YvClX2NOHNgrU0Rhj4Y9OW80bA7AFiECba4AEjlumT4X3pmMCUwokJIAQI2LwggdKc1Kupf0cAB5H5KLS0zFlRhebKf3S1RY3kQH/80GslpBk1UH5BVXHd0Qq0wxfjajPci8Ahaykdvz74evlN5U/aiil+PailSGksrYNI2AG7oqNY1CoP40EX8YOZspEtVD/0vWjI0uJRN2sAm44RyC2U2nCRhLl2tUPvp0Vxsy2QH1k5BHs=MIIDTzCCAjegAwIBAgIULi87zlNPgFfrfza90D0qxOeFq64wDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnmVynqMSN68BFs8yfXfSpsNbvF2bRYouA3Nz/76fHmshN4Ngo76I2MEoFKWgOgcHCx643oJ/uxQsCY956igWRT8md7oDXPWJZ+aoomG9bRCjbx7XuUHzMl+fBdKWQMBuv9Zq7zGMpBhUUN5t1JI6a2C/IPPVb+tM+yzsJIWUvEi3HQ8DHhRL2m/ZQ8qhnFuIkaNqHeAPHrgOGZQyS+xhb8DQdZyVT1B7hOG6hyUgiIUiiEShvNdyDGLPfsJOrIdBHeLxwAvZ+a8AFWUF/G/9eOpuYl3oHd257+FcDiIDS2SFJwdetmX0kXnK6b2hPIVUb3KLc6Sv8kS3s//vFf8alQIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUq7+eMJ+KAsGJtpkWoS+dWtOx6gQwHwYDVR0jBBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBABkp4354Tsgcj4HtAXQZ0OopUO8GWaOtvn907eC2GhjaP+6Wu4EOaSkIXSjgZmDkoNtEujbYFXhXpWrxxgg3ZdgKP+ywtX2vyudC4+L2h67mZA1edx6TFM74gN0uxAhk143hApd1/TNq0pR+MjIFZ5sE7EB06XU4T+mvgIQdSQknZukrKT9gnLw/6jrq78MKgbECd/U5VbVju9rbsaazl0z49GBIr2+xC0JP5g3+XqORNhaP+6+SAMkTegMYKXgRrj7WBt91a7NBxjWQMAZUL+6XYaNdQLB4niJx5Gcr9fZHw4SIZbax6BNYU1iD6zbPfWq2CygdQkT5kWG8Zvdxz8c=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTE5MDAxM1oXDTM2MTAyODE5MDAxM1qgLzAtMB8GA1UdIwQYMBaAFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQBI8SxGsm8fURbN6Fg7fj0uo6E3UkkSdTgGHbU1lhaw0FpZTYlHjB3uNCaJ8QDJRm36qWPWGihGvQk8rgKW9T4rEv9X+q9r8eNWNkWkAKXWYobfpxgV8neEBRkA7CZwCUF84a0eVAJ2CbOi9pR4THfetatNAszG9T+69Mfo1MqAphdrU/BaPOvWh0PH0b9E6Vlk1p70P3RxPMqwzlqVrURYjHCByWetWE2+oI9+llCRAJB9X6zT0RiIJgt2BDQ+MdbBLdOBf3GihKL0yXON4qzRnXKVWdTFqNxRMHFAU1hrzl5G43ZtTMsgktdqmiyVpqztz9qJKHezp1esIVX5ORyjMIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzExOTAwMTNaFw0zNjEwMjgxOTAwMTNaoC8wLTAfBgNVHSMEGDAWgBTOHI7zMsN8ofbAx5VeQe+jQlshzzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAGo0fqmNfdqAz610FQHLMDz0IOVc2mtJS72b0vNybXJkY50EGJ29XVG0DdMRdLxA/46sBhTzR61CBD3xMm1HWLu9COPZi/N8eG5YwU1ZjuB5jMaBiVI35nV9bjKtPgBVp2VnlsVnl9IJax8nhD66TPG19wpR7bwgB5qTP5XHyzVbGRe3zLJefvSuxtpHzXLaVt0hvGdNGL5RzfkRt6iH44h1L8xCQN2POb55V8xGbBqc7VIQZpHYZAPWuwAPG9JbRCJhoy1n2QwRCSBLjqPGxlHYzVrTiTsftrvBdlh9ptTbl00s5GxIvHmlJk3RH7IAAyS7wdj3VR1tyLEUBcx/Lmg==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 + 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MIIDYzCCAkugAwIBAgIUIh64wxcYdH4m7j5qvr+n5NHzy2swDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgT0NTUDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMJfxhp12rqgCA4Nqlz3TXu4kSN/g+9vh7a9fTUFrXpWQ1bBSfaB+uwK0MSBkA5U+nn1+zrgRaGppmoxksPVrEGAzs0k/JIi33khquG/wECsVVQdoFef9b+AC3wk8xX3uV3r3d5ZSiuUqwEUxLw/vk5ScVetnlbrNalhEmkED2xO9fVXTQ8fOfVhsl1hECYe+5TyPhkLiod4JXZtvsE/lEnUWV4Anu+UvLcf+vbU7Mej1AYiH9H8nVfOQbk25eBCogAMxLqV6X3KbHsTeMVRTF5vdyxiTUo7NusfICJWqlKzWFq+SqMCg0lUUGZTPru7sLFh1VicfNx4HpfaTqd3by8CAwEAAaOBijCBhzAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCTAPBgkrBgEFBQcwAQUEAgUAMB0GA1UdDgQWBBQLj1e+4lbZ+qF5JhZdNcqVhQpeOjAfBgNVHSMEGDAWgBSp/zBwkOhyLj5VTSRA7711TDrqZDANBgkqhkiG9w0BAQsFAAOCAQEAXbbgpNSY/ktrCaGaJNBwEb6wn5nDmFa74dDS8P3Zg4NWolS5Xbc4TyVHl9ParBHj50OIY9jZIRTT8hPfB/eKq+4Xs+EmnqCMZCnFU5bgEUd1VB4fRsoVhk6mo6XN4NlLmD3uTUlhb9JDrGeeT6BWv11J9+6fqm3T1GpDCM7+Ojtyltcc+ANSn3ngzllsuOffjLskY0XUWhC/Q6h1INDjp5YGlpAAVUz8y3b/kU6mx1Byx2rbirwybM73HpV2g4oPpmRr570RRPUgi6Y2ok7B0ID/Yq/fMEy7z+9hK8pxFIhDb8XULsDhsxS+qrh6r2GDn19H0SmW5ZOAFzVjSmoYFQ==MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==MIIFdAoBAKCCBW0wggVpBgkrBgEFBQcwAQEEggVaMIIFVjCB0KEmMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AYDzIwMjYxMDMxMjIwMTQyWjCBlDCBkTBpMA0GCWCGSAFlAwQCAQUABCA3iGa5C6sNo7LwW3cZojR2nhyrmqI2B+by9h+TmsZ8aAQgEas186GWnGYTFz7YAWCTxv7ZUXJbcD7wOxFM3XD3CBICFCPpoWaJ+YJt6cUfTZoCRX7tLrPHgAAYDzIwMjYxMDMxMjIwMTQyWqARGA8yMDM2MTAyODIyMDE0MlowDQYJKoZIhvcNAQELBQADggEBAI69xNcP+V6Yo+beoSJPmEpymr2JqMJXFTTBKEvtlrPr7ih8iZCA30jVyyURTty0npXX3pxeO8M8U+zV2Cjce4kJLQXwqKfLkRWctKFbADaEB4oanKN7OHfXS2877fKkOpT1WWwRfZ3rT3XLy0n+BpTjmGWHWNe9IW3T8/Ad3XK8YKmW4aMb9XaHBqwyyUSBLIiK4n23o0ivk2qIArdv6OD+4p1sxQWeg+IXM9RWAyknHGsss+hCUKOLo0jO0wyJYZqay523R48mqqpjBkG/bij5kIgZ3++6SRkP5qXEBpi9Sx8Axs05N39FBXqtkBBGmaq9b4Sc4nRwxi1ZhVKSGIWgggNrMIIDZzCCA2MwggJLoAMCAQICFCIeuMMXGHR+Ju4+ar6/p+TR88trMA0GCSqGSIb3DQEBCwUAMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFkRVMgTGV2ZWxzIElzc3VlcjAeFw0yNjAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCQxIjAgBgNVBAMMGXhtbC1zZWMgWEFkRVMgTGV2ZWxzIE9DU1AwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDCX8Yaddq6oAgODapc9017uJEjf4Pvb4e2vX01Ba16VkNWwUn2gfrsCtDEgZAOVPp59fs64EWhqaZqMZLD1axBgM7NJPySIt95Iarhv8BArFVUHaBXn/W/gAt8JPMV97ld693eWUorlKsBFMS8P75OUnFXrZ5W6zWpYRJpBA9sTvX1V00PHzn1YbJdYRAmHvuU8j4ZC4qHeCV2bb7BP5RJ1FleAJ7vlLy3H/r21OzHo9QGIh/R/J1XzkG5NuXgQqIADMS6lel9ymx7E3jFUUxeb3csYk1KOzbrHyAiVqpSs1havkqjAoNJVFBmUz67u7CxYdVYnHzceB6X2k6nd28vAgMBAAGjgYowgYcwDAYDVR0TAQH/BAIwADAOBgNVHQ8BAf8EBAMCB4AwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwkwDwYJKwYBBQUHMAEFBAIFADAdBgNVHQ4EFgQUC49XvuJW2fqheSYWXTXKlYUKXjowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAF224KTUmP5LawmhmiTQcBG+sJ+Zw5hWu+HQ0vD92YODVqJUuV23OE8lR5fT2qwR4+dDiGPY2SEU0/IT3wf3iqvuF7PhJp6gjGQpxVOW4BFHdVQeH0bKFYZOpqOlzeDZS5g97k1JYW/SQ6xnnk+gVr9dSffun6pt09RqQwjO/jo7cpbXHPgDUp954M5ZbLjn34y7JGNF1FoQv0OodSDQ46eWBpaQAFVM/Mt2/5FOpsdQcsdq24q8MmzO9x6VdoOKD6Zka+e9EUT1IIumNqJOwdCA/2Kv3zBMu8/vYSvKcRSIQ2/F1C7A4bMUvqq4eq9hg59fR9EpluWTgBc1Y0pqGBU=MIIDTzCCAjegAwIBAgIUReyPRoX4QIp/sA5y7MLAGdGkGRYwDQYJKoZIhvcNAQELBQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowIzEhMB8GA1UEAwwYeG1sLXNlYyBYQWRFUyBMZXZlbHMgVFNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArRuD1X0yOHPYNXJZ2SIU3TzV2ghkX6y1AmEdfCC4cH5gQgZ138/4NqtqDb6z6qqtJmTk9uZbUjv8SHzCrIkNwv9Jx3eWHoWeW9v0TDe/988kRonkDi2b9kHAwsPebGdVvOuAgbPUVgJOr+8EuddE6s5rbrB2kM4X+JJED0cLFvc4itCEEO32urE0ZaLCeI7UmVMjZVXCKd3uPlEjoVwE36RbY4oh4K/4pXryYj8CN+a5zFOwyWb6RbJzqOSzKmUV6op0PcMkgQAdFUTC8ahKHS23D2QC68isFAQL3zgA94Zhtgq97q5dGFO2iVG3QYASRMyovecEVXoOFkIeXWx8KwIDAQABo3gwdjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAdBgNVHQ4EFgQUMCm2YgSGjxFqJtNT+lFVVIowcAowHwYDVR0jBBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBABova9fut4uLJw7gB3rnxdDaOjcRan9ORUgpx3mfObsJ/mYB4pRef/M7UrBWTMfpddpAPo/yYjWAT1cM4r5iWaNOXVTjYsYFDNikZonCcfK3iJlNg8M8fcqA3JbFaDl1N4/ADXxfEVTnr8ZVTpgau3fwpvOORuLuhRfUYtyTI+/hOXQvBUxYnyetpFVVbDOYstUcje1Ser1o4b9EJNvyRedcL/9b2N012k3IO2rOITqbvd4d6ATroBzxyBEy+F4lb752Z1VmX6BApl8PLB+HuWu68DWIdub8HQrfujFl31csWKodxx0qEeBPIMNdf9EYPCf2wOL7ZOkao0Q7d93C7KE=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MIIBoDCBiQIBATANBgkqhkiG9w0BAQsFADAmMSQwIgYDVQQDDBt4bWwtc2VjIFhBZEVTIExldmVscyBJc3N1ZXIXDTI2MTAzMTIyMDE0MloXDTM2MTAyODIyMDE0MlqgLzAtMB8GA1UdIwQYMBaAFKn/MHCQ6HIuPlVNJEDvvXVMOupkMAoGA1UdFAQDAgEBMA0GCSqGSIb3DQEBCwUAA4IBAQA1IWUYtCAUKKzYFzQZxRaZfRGrlY9TrY9zDLNhXTpw2QHSj3TXWsp4VBc2oveTvZE7U+8/X668AvZ42eXxdTvLIgtZeqmQsJ7hY/MYe438/75xNZF2peZoTzveWXar8CcvKNnmhjijYf1PZeeQL6U9wAAMOxT7PSbn1KtZER8eDKKkO2bbRaqj2STwD+Tq8A9HJE6xCOu5E7eMKU391/WEFTCW6c5XuYDnrlBB94bRuovoPuSVEwRBVKfQKj95AyuiJWsaKLtN1LiPM1fE/kniKS6ybzLzwdnuDDuo96ZVVeAkx1EwLkHtO/vT5ivpVsGRf6aShiHp9L1N2deSZ/W7MIIBnjCBhwIBATANBgkqhkiG9w0BAQsFADAkMSIwIAYDVQQDDBl4bWwtc2VjIFhBZEVTIExldmVscyBSb290Fw0yNjEwMzEyMjAxNDJaFw0zNjEwMjgyMjAxNDJaoC8wLTAfBgNVHSMEGDAWgBQUBPmNKWYSP62c8mUyPtevHJ+pxzAKBgNVHRQEAwIBATANBgkqhkiG9w0BAQsFAAOCAQEAuGxv1qVzUhhmF8G/YgvUTED7Sd5Xg3iWbufO5bUeds8sW1qnQGY/VlPE2MNQZvxD3qFNgy2qnXTG8+qLQ88aHXh9DmahxBUmZbU1oFkZm3X/cvIKbRHwRBTrQ0aB45vgs1fsFX9LUmgaQlaUZ23p0gkqeU3YN47gV0z2Bu7x4/0DB3pYrmv5ERgFah2XiRfxCgmWIFobWfPTaDjff1O+zs3GHHOHOGmudVgfby7ioPB4aRlzh4fXAd2ynDjzunmF/194S7+TdcJ5tr2vhlaGeDXvIY2jdqnDxVid3AS6okhoeXCVh3RFGqezIhaXPTtO/FX6dmQg3NlGJ3ZhCG775A==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 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml index fc328613..82e9f835 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t-no-accuracy.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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 + 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 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml index 6b92902a..78fcd8cb 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t-parallel.xml @@ -12,52 +12,52 @@ - RxQWAG1yIIJJlD/GQaZIR6mD3ZqF1dJFBurNLuZ5PGc= + WyfDT3CGVXbueClRvzJyrRsTH/jVPybQUxw1UvaP1oA= - l2A9ubvznY0hYnFa1jx9MtSgUfVR/6a4aqB8Dp5w6McQagVjRTcwP+GVQrsYBn8a -E6Q1OAiEEoeW6W3WKQV3xtcy/q+KzSrAE/thgcOwRkxivuh6IjfP2EDbq1qirF/d -y/X/DjLq5fOogGY00mpuiKHrT2fkd84+kDffsgwsZTZHQOLt3hQxBpqjFGYkj7CR -9XYGacVNScnHtZ6IE3Ssp/LokBszRYUkxL0nfHcv9a5Od3ETmqBmIfEDMGitlBRj -mtRNF4BsiBf5LIuI+6kQueDmzedp1HQ5jSupWAbA7Nz+PbfVWeB1QGDbNyTwD1mO -/0l217BzeynS9mPzG2rC9A== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + IqgFXlyn1nBpKCsBQBGpcikFyv7mIaDSBqeWxB59PoTdQqdcFAusV84YXX9x+Phz +OI3K9O/TC8bdRGuTFIyPJrwdvXIJE5AAB93X9zkZJwg2AGrdiX7t+3b9DVyqHrAS +vv06z9Ajj8XS+aIFLDfQdeVUfXObLmBJzt/IfNgMSu+dYxb2EcGCD/H1s8+4CzWf +F6OGh7nNeLJIHWnOGNX2TeYfJVzYn7au2Exy1teMbD+KlvRjA0OhsyTe3vhMgjg9 +SOKQEbyYTjiAi1pUrWjHxY0G4sQaforEaCwhS2aJ60tBBmRBzQ0j4F5Klxjwa/n7 +66wo/AtcWYzZZonr/osj8A== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -69,7 +69,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -81,7 +81,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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 + 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 @@ -96,52 +96,52 @@ ARrAZvqlC+ytq8wqC7ARLBIl - kthBYSER4HIKUkjDSUozx1OURGGv9mgcsswe2cPDG7k= + 7Mj7Q84wuulcSjTnJufopThDR8WrSmd3pv2XcKSBY0I= - gyyJ3Gs7m9qc9Q1XNorm5qJZtq2kWtiEYinov/RZuxspGbokjMm/0ki/mXIhC/ze -TEIpIBenwsg/w7tIKZPB2Coocmm9ZEt0kq2W1MnS2PDg2ORqwm0/UZVBV3OzFzUX -yTJ65yygTnmLJCAk+AzszxOk64nb8YdMGpIVO6i6B2jpIA5CuSAGbD3Tns3CMMKk -+aifRyQewBChi2Bq1XrGnUoqNSmBuPtsW+d6i9AXqfdzMF86COc/KFoclYCkvTUD -Y1hkwc7YY6X4fm+sOnHllgW63AXWyN7xslHKVdsvlLmExpbWvuMwNH+Pn3aVKpB8 -mM+hd5A6rHYV4LMkpdqUtg== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XHt+ewU94RKV/oEaz6Rbg170bpsFJdO/MwRh8MWPJ+tZ4kOYKwR5alx+P8bj3LLl +yjDgxz6GwWi30ZJah+PJuv6IFql2lZYZ8qBgPvrwTAAFI8P5sCVb4kIlz4eHcZP1 +gydHplRRhJeQKHNZO+gGR1a1ZWiVi5Hk0vjHux8nLpWuyMI+a0FyRWPb3ymg4bpa +2Qym6DDXtlgTMYGpeHtlanHGp5wFnNHLkLM79ZJ99vLjCw+zcASvJPh1A6kCUvtO +IQrQZ5L9mrVhIj1TfDbhRIRBVolVIOEHiwLaE4mHgDFNRK1pnMEwMlO5vIjUQ51/ +P3rrmuKxcVCmOAMlZZQPYQ== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -153,7 +153,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -165,7 +165,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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 + 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 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml b/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml index 309a163f..ebdb75b8 100644 --- a/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml +++ b/crates/xml-sec-xades/tests/fixtures/levels/b-t.xml @@ -15,52 +15,52 @@ - XRxh1a57MyS+42aV/BdwdpMTLtlQjMEzfXx2W/LpDbU= + TDR7H8zAXUP/enqYkuC2V6XojrXXdGpu4P2nefulL54= - p+pBIDd7gYXmGvGnwxoApYlvyJKzTecspU8jIwJ+7H7Xi5o8rD0sorTIiN0ZZ9Cq -698sAfT+MYcEEM0W1Bmvt+2zXNTxwVCcWq68333MA0RbYkZmZ9NvP5Z+48aMI3y+ -EB8MH64w6ZHHjujj+qKPZ9qm7doESOzYVMZEEomSr5SyDFQ7i9BnryZyNVgKTGVQ -Nrqfs7af9b6GiIG4NkfnuuFyjSpIF2kRGvRUNj1aS1MtwchS9OK62FNll1GG8cqr -5AKC3IIVJsw6vML1ZOin2k4bI9c1ORjJSFfrhZcDMg3iNGOpNLr3wnCmYmzxDknY -PG19u661UV3b/B9UY30wug== - MIIDOjCCAiKgAwIBAgIUEtP+apS9r5y6gzIiabdnRXiOuCowDQYJKoZIhvcNAQEL + XC2ZBmdLAZS6pQUzU1FEFoqNT3pQ8BFLkCDZR/RHuhXG6V9rF8s0XQpWohbKHmI6 +oiADN2WUC1sJ4+zRm8+ukYRw9cic9w+sYgPc/Ac0W3763RY9luDyLSHwf/FSsBWG +N7zv5ou3xQNTRh3o7r7gIQfUijx03d+djfImbq8yhJcgWmwkLp6g/gbdvGdHHFt+ +CF1dOgAOunVGbSLKgVcOfmLahZjJIpeL5yZVPzpT6+aRjuaRNrrzrEZsj88v2HFd +WNVbmMm6EV9Zn73PC8PyP62Mxdj4epEenCcGVEABDEu2OMEPJzU2t/RcGfMhvIew +oJV8saGVhkvYHsmthVD1tA== + MIIDOjCCAiKgAwIBAgIUI+mhZon5gm3pxR9NmgJFfu0us8cwDQYJKoZIhvcNAQEL BQAwJjEkMCIGA1UEAwwbeG1sLXNlYyBYQWRFUyBMZXZlbHMgSXNzdWVyMB4XDTI2 MDEwMTAwMDAwMFoXDTQ1MDEwMTAwMDAwMFowJjEkMCIGA1UEAwwbeG1sLXNlYyBY QWRFUyBMZXZlbHMgU2lnbmVyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA19uaVFdqw06ZVahjanlm5svo86Oxs7fw6G+n6yxltLvU9YPiljEMVY5nt4kb -KArcQd/0ka7kHJ8ZLXcy9kefHZgQrUYJLStRs1bTgXSW/2NrWBVhbJ8DUn/eWW/N -BPiU1P6l6Q66yTk3yJH/cw0FbfYqhwS1XQWtboOmXBrH2719KuGJqjIMmTCQiBui -lrFi9UvJKMNW0PpWDHIygNp/eHxEakEF/rknKXHle5PoIJ4VTRHYUc9WvyEDCAwV -LPWymOCVNEDthNl/eXRX7wawtAe+4kYaY4F675OmgR9GoedZ2pXKtMeZ39/rOKfR -ezSaIWQivRcCY63LTdfrMRWccQIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud -DwEB/wQEAwIGwDAdBgNVHQ4EFgQU3LFNY/g7GUy0N40KWQCd+/1mCr8wHwYDVR0j -BBgwFoAUADNDK6gbnu72J9U6xRj9lDpIMacwDQYJKoZIhvcNAQELBQADggEBAECa -gxvVUSlqohpWeFbTpEzOnugzNCj4zwWJKB9tmx+ZECrnXogeUUAE36LShxNkTfgX -NdVreS2D3/jK3/A8BAgh41OV3GSV5+iQcSG57FymV5nSN3NOxyNT31jbN1ge2c5D -2NQGRZ/KjWHF9A9mzyI5b7BjFpWzGlghq3nQDF7l0oCQ8SDveCN5AocXOCZf//2l -kbJRRttbPXWha2DHGGuIaY1ZF032wauBZoKD1OEhZVmMdAgE/c61wTk/O5e95Xgt -q+bGN7TPp8raOK9EK0++GQMXtacGR/ZrIFiE43v2adXbLUJnWbdyq+7TwJxGNLnr -4Z4RqnYHsCZ4cWOSXyc= +AQEArN+GhkyMyYfCJ+2G2Lyj6iu8ten/qyYNtdGBnYrDH16Ce2CrEqN574X/lwC0 +44sfgJn+Jb1SvsVBMs1JyG0OTV14sOCG8SlZMj2U9cmxjS2cVWnhF+Y97j4AH7tD +3BunGq/sGTq3wacdx3JdarPRgXyHvItkqJvHRNZM5I7Jav5T7Ol9k8C7/TssMzfe +FshEmY6w4lTaiCPAQdDdO8J61nJT6N4LNx5+20jLMHUm9Y2KtYsHG3pS9QezwjLH ++9wf411N2EvkZpnlPOPFudLYH5IaVhrJRCLZRuX9l8zQYOIzad6Bqe4j7ljvznxi +wyF3+n0hflDVQAU/9tVrQw5PKwIDAQABo2AwXjAMBgNVHRMBAf8EAjAAMA4GA1Ud +DwEB/wQEAwIGwDAdBgNVHQ4EFgQUUC4Ipuk+clRLYKVGJvQDFpgUCMQwHwYDVR0j +BBgwFoAUqf8wcJDoci4+VU0kQO+9dUw66mQwDQYJKoZIhvcNAQELBQADggEBAFNB +LqnMFes6VdvgxTKG8V3BQw0jwNGfLMNyEYUq8YXXJIF+oZYceA4YXHTTY1yVK2Rc +BY+2XEFhU0I/OV7hs6AWMWxnBcs/Wc1eJhaxmtdhivecQ+RIbFskVKk+vVBovKx5 +w5Z0Eu3T0wpPEOr8SXoVMK7wAHZUmWh7bZpS4fXoe8r8gMdoDD9dSsEJ/BLB4kdC +yWkiDknQ5H9489qnR3XfZrQk5r9NxlfA0GtZbfZhnZj0GsevpUyn6I+24mpJ2Vak +hK0vdtmhKEi77d7cye95U3ojQvZtXLNS/t7d5ePdy4UbsOqzZ7ec8XF9R0sbghbW +IUty1WVWuLohjxZDQDQ= -MIIDPjCCAiagAwIBAgIUI9JmcUCvCPYNlh3QUx5NlichlvowDQYJKoZIhvcNAQEL +MIIDPjCCAiagAwIBAgIUEDEm1Xs0dP1tFPbDTcBJdyjJHA0wDQYJKoZIhvcNAQEL BQAwJDEiMCAGA1UEAwwZeG1sLXNlYyBYQWRFUyBMZXZlbHMgUm9vdDAeFw0yNjAx MDEwMDAwMDBaFw00NTAxMDEwMDAwMDBaMCYxJDAiBgNVBAMMG3htbC1zZWMgWEFk RVMgTGV2ZWxzIElzc3VlcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -ALodAAJRbNTvGSQ5VNwBHHcvG0watvz3wRKV/9LRFLbgewCMmCaWgAiDaDt2jT6c -mfKa5E91f5aZmVfRbdwfDfpSO3HjSiQA2m/jnd/iy0nAV+xx658PrYyopbYIssm1 -Xq+SrFt/mNgQgp2QzLx9ePnyo2q1nW6rG+YsGK2HxkMFjfV4iCtZ24xchwn5it+y -YXIgM0AAk5/GMqQrvPLT7Dvi+Ap1FQJXCpsv0FVy2g5avaGAysoVJEE2vF55fgZE -ZfxbUmdOR83SDQaQI7clR7/rRdzh2s/ZW8yK0W2jGFB+U4lSHEozwSt/tYo4OTeY -dtYZ3gnt1cMKvjOKI9NJEY0CAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFAAzQyuoG57u9ifVOsUY/ZQ6SDGnMB8G -A1UdIwQYMBaAFM4cjvMyw3yh9sDHlV5B76NCWyHPMA0GCSqGSIb3DQEBCwUAA4IB -AQBluDDgkV358xS0okll1Tc3k5kyX6BMwBbB+TNCPSK5bqZ+998rzuBS2Z4/3OLv -XNE+zv0nRWynzNK/qsZJMRbRW5LgEY7LLrwxF3wDFvU61pZ1h7wUh6ByuG1hagpz -bkAKujLAYFlsGvhOXjaphtPYhVMotoFfll1IL/keVrLuXVM+r8Px25AhR8mfOuXJ -YNmS3qJQwxNN/J2On3z9bf3mQmN2C2zfcgnS/Zn+JO/NfSIDyWCcFuzY8p7WVkjy -z+1Tf10nqZUR5z4PBWeE/Z/Knj/SiPtVcXbt4Xp9ORMtQlbVLyOHaIrhR5PzUraQ -ARrAZvqlC+ytq8wqC7ARLBIl +AMff4ONfb+dVmQDsX7G3gnvkKS3lfjJUh2rk5gNGFJcKGrhw7F8NNtPuSB34yL1M +aCLSikUkQk7Xmdi6eQ0gkGHdH+Lq+WPR+p3+sTM7khw2/K2XJBAgJ7Sf8T+gPjEn +ve5zcxaaxF2Oa8I+Z5UABSEeThIm80qcLqm8/aQcPxiGTEOxKKB9OpMTiWWtbTJT +EoK1C2ps/uh9PJe4rt92q0gjo7ggud8ZL7LM8OS31xSOBbraagwNu8A+9sIZ8HIf +bToIPDVzRJZcD/cujBnBSEPB/FvjdZ0EhvbBAFk+aa+3KiIMPCqcFTcIvSrRrWmh +LZQh3ZBiBbcahjfHiWPtrIsCAwEAAaNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFKn/MHCQ6HIuPlVNJEDvvXVMOupkMB8G +A1UdIwQYMBaAFBQE+Y0pZhI/rZzyZTI+168cn6nHMA0GCSqGSIb3DQEBCwUAA4IB +AQCKv6N7qnw3wmk25atcZ2ZbGc/MOSsqGhAvlu3OCD0dOe3wdmgyQNuo/WFl0B5a +XwCXsXT93mTdeiVNi3RSITRtSLhD8fGgw5Dq0MPF9FNmv3O65TkjJ2lEhNULV/Ju +PKVoGO3PPqMwsfnV/1fhsXNwaU47Nxdl6GEFu/BXJCLNtCu03wd58PTRouAXO6ML +Rhm9JIEhprSV6TVjLMcVblgUZP7IXkNgXcUF0fPBuIrlS7suczxCOOOVrTDpTa/R +IK+vTl1hot3Au53WYavRUNL0E126YqjinW7TkK02n6fM4kBpxOui8WiIYKCCpyif +VL7mBUrNNo985oDyR+xacQV7 @@ -72,7 +72,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - jBSYA1iB2PPsHZFsD72jzjxEdOCnrMIl0dutdm7xjUg= + nVY2YIvKdLeib7zSLCcu1dpE82sIK+AsyuY6WlOhNlc= @@ -84,7 +84,7 @@ ARrAZvqlC+ytq8wqC7ARLBIl - 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 + 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 diff --git a/crates/xml-sec-xades/tests/fixtures/levels/issuer.der b/crates/xml-sec-xades/tests/fixtures/levels/issuer.der index afb67f4f71f337767ef556fc7bea3542cf52896f..c8bab581a04b52845bb6a60c5764c0d5a56c75e4 100644 GIT binary patch delta 638 zcmV-^0)hR)2Eqm-FoFX(1F>SQn<1_MLNVr4s@u0(y>d?c*^iyWP zbGqd@BPVG@gw+dI@@_n(Xc+C!KBF+P`PKhd;jwdYX-+#g7iH*S1-tN9BqGhUE41GS zdGPenqTm-hqYFkEy(EDlrnHsmHDfHt6>eA*Wd6urLttIS1<~`txQgXVyDoD)LQ6Q~ zm8~%8O|Q`)udhyBVWQo@yPeiytI<%>^b=jWVyNPsZqtyhHlL@=;y`J{>!R^!h+v?C YrzoFPzUBo=%{GsG=791?>{@XJdstQ{UjP6A delta 638 zcmV-^0)hR)2Eqm-FoFX`d0F0O>mVgL@XghX|KAf5In&eM) zf0mh~ZU#53P)-rM3vN$+cdulB`>QnAi}4 zosi7DeR%ouqiVICZmS#SEEuha#zTJvjrDklD_Pr&T!#tyir=zfav(E60F$4_GNdcK z^3&`);`j=66#`cZn=jB+a@r1By`g~0$`vF*HoRVWeg;Hk{996IPDjns4F-@SwqXq*+Rxcr%!<)%qZm+rQ;AX>N;APLf3=D@IX9Sg)*0Rj?bX8yzB7s=(@6pmjg!Fv zIDY^$Lo28op6>Q1)jGu({ggULF{dye1_M<6UHS7Aw4zC6)i*bjnKECXOu!bw`7=U2 zBDrp+e)r!i&frqno|5*F&BIT7WF#T zmUV}`6o;U4xNTu-3Uh8i3c51DU|DP$_)cCnsfN?og;OZDfnSzgNH6&wRcJ1MMeK`{?LRQr;BZp{;;YXA6 YQnru*8o*}yr3>t>tIR43un{a0C5lNbqyPW_ diff --git a/crates/xml-sec-xades/tests/fixtures/levels/outsider.der b/crates/xml-sec-xades/tests/fixtures/levels/outsider.der index 706a1364c546f47bbe7a96ff6d11d3800160233d..073401cd0ee49690e9c5abf97ace3e3ff7a927dd 100644 GIT binary patch delta 638 zcmV-^0)hSA2HgfDFoFYFFoFU>paTK{0s<6DDJ+m%0y0RiA_f;NmoRCX{tRc4Bd348 zUSB#d!t+R^`Mtp5EWA`JvAN9RYKJAzizThP6k}3}b=PU2Pd+?p^jmZSDnUQx<_eHR z4Wdkal)#g%L@1YCHjtM;r*K#Y$b^sSw+j2>zN>lkvyrMMuuC+LdijVy_e5%Du4C|~ zwkdNRjghHzvG}t6%c~N$W-Cl?92$Q%dRE}<47;DUQy*4hMMIY+&2f(As+V^zrkuh+ z-+2hZ!Kl8cuSAqSbotE}25Bi&lbbY+A98EM@KU%*B{zT>2&JTOAFKrpS0tzU`*oUL zTlc6L$F=q4+u;Rgf6VcCzA3PKC_}&YN1*XFN>)Z&A^OV4&)LA$dqu4fH|qk4$&<|?!)=zElpKZM|^+g!rg?It} zAwjW!Ia4|!vAwOz|Cnee@t{5#wY;njjAw5EjFc~!_U!eR+gp?r6#GM|A!_kAf=h-w zf_8#$^nG*b&zn<|tY^@7aC`{HqBUq)xk0hPPBRRa%Q~3#!W#)f_h4I%W}go0&$f@- Y#{M;3m$FdgQIKUTIz{h5Tc9Z_=L^FsPyhe` delta 638 zcmV-^0)hSA2HgfDFoFYFFoFU>paTK{0s<6pdH`o{QUJ`7dXq+yvDZ$G%hY6%Bd33_ zEsP(f+ntF7Ykc|Am=K3S!{2EAfE3>uWs2mbC3oRlU-T$4to0tHYcD$)dbNnc+!22J znMTpSs}T>HAd3GNU-Zi|#BJM5=Oe#Np~;_a&6<2XO!`M=wyv<{ZuK-G81iZ?%al|O zJms~I1zhRbfK@EShBu9LP4R=jLREkDFK|hj5n$~=a~!Zi9!h+8H@mAMLb*q(K$mAH z>^*CV4L(>~z|PHepq+r*m`aonn2Y*XK^sMIpRl%9Yg1MWIX+@_Fs@kk%*)7+6=*ix z9t^2zsu;qN!Nt++!!jGN%df2-(QY?>I&zi>#jz|1&@`ruuw2pxLbq%U9~%NF`IE{4 zN`JJ#y~9TTIQtGHV>*Cid*%C)#BeYl1_M;3Q+ zj;f;|btxT}Z71y$Xi2$4y2uSxQ@y%O;tND=CMEpxSVZ%>hdKg3LMLs7dP3rUN5B@t zmCtbo3Gckox_c|a;wOEr2y}Ez*o?Tt_^jw5vZZVtNNJ&?{{Vs$Fx>Xw5RsA9PfLgB zcz&kkTg&O54q4b2s8#u2$5!{krOWG(_~`dA4W~16Rwn2u{Y`biN_!AKsxQnOsUN`v Y$}y;DTx?Hpk$)Cip-kv7q&>sr%>)H0_5c6? diff --git a/crates/xml-sec-xades/tests/fixtures/levels/root.der b/crates/xml-sec-xades/tests/fixtures/levels/root.der index d3e2e8b3f215fee65e0bb6202c423f60c9bd849e..04bbd6d47266f565d513d81b43e3d12d75270cf4 100644 GIT binary patch delta 604 zcmV-i0;Bz$2Al>XFoFXZFoFUApaTK{0s<6tsVG}tS7FN5xIUkQmI&O+`t16VBb|S1 z7j@Tullje;<5&)UM1fO1;~}1?nUmNzwL-Pqxg3=K!1}}ozfP4Z3<}y+gvS7q z3yt6VnjQ;&$hUrTFRAHYv{F0+qrS)XqBE~p9IJtxkVw55Wma3T(2uf;Sc;9}4a0$| zQLWP{?Ck8>71bX7;QYY*@i1F*`CorSHDKHwQCP_S|74xc+SGma#d%0Xz-hf!{L((Z zyNXUrlN|m%FHIQb?ySMg@oZwXPrQphWm;8-^f8i;jn=Pv0o7yL87Q#^_=v^T>1Kys zDB$dCe0!EQ`(3Njzv|)bZD)+Q&`RmkM1$B??>g!1-Auq78o`c2JcP@L#^7rd(20xg_Ws55^6 delta 604 zcmV-i0;Bz$2Al>XFoFXZFoFUApaTK{0s<5U{4L>M0%W^B)CKv`A8wzmhWT!hBb|S$ zZLv+f;LfSYKv0HVQ_T`lZ(2u<`8Cbb0oBr=T=G>~h!LzH?fgL0Mz z9>k!OHaya4`xm{6q|MING0yIO2W}gvOGQ)hK_Q1!LUP14pLR%rvlji|7e}CdPt2OMF23uld z=b8e8$a~D-l8Xt`RS4I`zNZf0U5epAdPszgo)b)1?KV-~*8uU3xeB2rGSF_!_7Ef$TsU#)^-F z5t&-+Can2gw;c11k`(U$Z^nog;O16-;@;olRdPXcQ6V@6551Ae+cE9VNFm6w%v7e-0>xAASRyq5 diff --git a/crates/xml-sec-xades/tests/levels.rs b/crates/xml-sec-xades/tests/levels.rs index 124839d7..4f387456 100644 --- a/crates/xml-sec-xades/tests/levels.rs +++ b/crates/xml-sec-xades/tests/levels.rs @@ -17,20 +17,23 @@ use structured_pkix::crl::{CombinedEntry, EntryLookup}; use structured_pkix::temporal::LeapTable; use structured_xades::baseline::Evidence; use xml_sec::XmlDocument; -use xml_sec::policy::{Instant, ManifestProcessing, VerificationPolicy}; +use xml_sec::policy::{Instant, ManifestProcessing, TimestampTokenEncoding, VerificationPolicy}; use xml_sec::xmldsig::{ DefaultKeyResolver, DsigError, KeyResolverConfig, UriTypeSet, VerificationRequest, VerifyContext, with_verified_request, }; use xml_sec_xades::{ AuthorityAccuracy, ConfiguredResponder, Inputs, Level, Outcome, RenewalFailure, Requirements, - StatusFailure, TimestampFailure, TokenProfile, ValidationError, validate, + StatusFailure, TimestampFailure, ValidationError, validate, }; const ROOT: &[u8] = include_bytes!("fixtures/levels/root.der"); const ISSUER: &[u8] = include_bytes!("fixtures/levels/issuer.der"); const OUTSIDER: &[u8] = include_bytes!("fixtures/levels/outsider.der"); const B_LT_CONFIGURED: &str = include_str!("fixtures/levels/b-lt-configured-responder.xml"); +const B_LT_UNCERTIFIED_RESPONDER: &str = + include_str!("fixtures/levels/b-lt-uncertified-responder.xml"); +const B_LT_UNCERTIFIED_TOKEN: &str = include_str!("fixtures/levels/b-lt-uncertified-token.xml"); const B_LT_CONFLICTING: &str = include_str!("fixtures/levels/b-lt-conflicting-status.xml"); const B_LT_CONFLICTING_DELTA: &str = include_str!("fixtures/levels/b-lt-conflicting-delta.xml"); const B_LT_TSA_DELTA: &str = include_str!("fixtures/levels/b-lt-tsa-delta.xml"); @@ -65,7 +68,7 @@ struct Given<'a> { responders: &'a [ConfiguredResponder<'a>], crls: &'a [&'a [u8]], responses: &'a [&'a [u8]], - /// [`TokenProfile::Etsi`] unless a case asks for the CMS reading. + /// [`TimestampTokenEncoding::Declared`] unless a case asks for the CMS reading. cms: bool, } @@ -88,6 +91,9 @@ fn level_in( let mut policy = VerificationPolicy::default(); policy.key_trust.verify_x509_chains = true; policy.key_trust.verification_time = Instant::new(AT, 0); + if given.cms { + policy.timestamp_token_encoding = TimestampTokenEncoding::Ber; + } let context = VerifyContext::new().policy(policy).key_resolver(&resolver); let document = XmlDocument::parse(xml).expect("fixture parses"); let request = VerificationRequest::default(); @@ -97,11 +103,6 @@ fn level_in( let signature = session.evidence().signatures()[0].identity(); let inputs = Inputs { requirements, - token_profile: if given.cms { - TokenProfile::Cms - } else { - TokenProfile::Etsi - }, anchors: given.anchors, certificates: given.certificates, utc: &utc, @@ -463,7 +464,6 @@ fn renewal(xml: &str, detached: Option<&[u8]>) -> Result, Validati let anchors: &[&[u8]] = &[ROOT]; let inputs = Inputs { requirements: Requirements::Archival, - token_profile: TokenProfile::Etsi, anchors, certificates: &[], utc: &utc, @@ -550,7 +550,6 @@ fn every_signature(xml: &str, requirements: Requirements) -> Vec { let anchors: &[&[u8]] = &[ROOT]; let inputs = Inputs { requirements, - token_profile: TokenProfile::Etsi, anchors, certificates: &[], utc: &utc, @@ -750,6 +749,36 @@ fn a_responder_outside_the_issuer_counts_only_when_configured() { assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); } +#[test] +fn a_responder_certificate_omitted_from_its_response_comes_from_the_caller() { + // RFC 6960 §4.2.1: a response may carry no certificates, so the signer's key + // may be only in the responder configuration or among the anchors. These + // responses are the only status of the issuer's certificates: unauthenticated + // they leave no source. Authenticated, the level is assessed, and stays + // unmet because EN 319 132-1 §6.3 also wants the responder incorporated. + let responders = [ConfiguredResponder { + responder: OUTSIDER, + issuer: ISSUER, + }]; + for anchors in [&[ROOT][..], &[ROOT, OUTSIDER]] { + let given = Given { + anchors, + responders: &responders, + ..Given::default() + }; + let result = met(B_LT_UNCERTIFIED_RESPONDER, Requirements::LongTerm, &given); + assert!(matches!(result, Ok(Outcome::Assessed(false))), "{result:?}"); + } +} + +#[test] +fn a_timestamp_signer_omitted_from_its_token_comes_from_the_document() { + // RFC 5652 §5.1 makes the certificate optional in the token. The TSA's own + // certificate is in the timestamp validation data, so nothing is missing. + let result = level(B_LT_UNCERTIFIED_TOKEN, Requirements::LongTerm, &[ROOT], &[]); + assert!(matches!(result, Ok(Outcome::Assessed(true))), "{result:?}"); +} + #[test] fn a_detached_signature_reaches_b_lt_over_its_supplied_bytes() { assert_eq!( diff --git a/docs/policy-schema-v1.md b/docs/policy-schema-v1.md index 7fae197f..a22b77e6 100644 --- a/docs/policy-schema-v1.md +++ b/docs/policy-schema-v1.md @@ -28,6 +28,7 @@ a disabled operation. Encryption tables require an encryption-enabled build. | `ecdsa_signature_value_encoding` | verify, sign | `XmlDsig`, `XmlSecAsn1Der` | | `manifest_processing` | verify, sign | `Ignore`, `Process` | | `detached_digest_attestation` | verify | `Forbidden`, `Accepted` | +| `timestamp_token_encoding` | verify | `Declared`, `Ber` | | `hmac` | verify, sign | `minimum_key_bits`, `minimum_output_bits` (nonnegative integers) | | `uris`, `transforms` | verify, sign, decrypt | Nested tables below | | `key_trust`, `key_sources` | verify | Nested tables below | diff --git a/interop/xades/README.md b/interop/xades/README.md index 7338c4c4..e1fe43b7 100644 --- a/interop/xades/README.md +++ b/interop/xades/README.md @@ -66,7 +66,7 @@ There is no Rust self-sign/self-verify evidence in this package. | Full XAdES/trust verdict from DSS | failed | All nine global outcomes are INDETERMINATE / CERTIFICATE_CHAIN_GENERAL_FAILURE; no revocation data was supplied | | B-T/B-LT/B-LTA over a test PKI (`crates/xml-sec-xades/tests/fixtures/levels`) | verified | OpenSSL issues every token, CRL and OCSP response; `xades levels` compares DSS's format and indication on each fixture, `validate` reaches the same levels, detached, parallel and countersigned structures included | | RFC 3161 token without stated accuracy | verified | Rejected unless `Inputs::accuracies` states the accuracy of its authority and signed policy (RFC 3161 §2.4.2); a token's own field comes first | -| Signatures produced by DSS 6.5.1 | verified | `xades levels` reads them at the DSS tag at run time, outside the repository: `xades-lta-valid` meets B-T and copied tokens are rejected. Its last archive TSA has no status in the document, so B-LT and B-LTA stop at `NoSource` (EN 319 132-1 §6.3(x)). `xades-t-with-tsvd` carries an unsorted certificate SET OF: `TokenProfile::Etsi` refuses it because an unmarked token is DER (§5.1.3), `TokenProfile::Cms` reads it as RFC 5652 BER | +| Signatures produced by DSS 6.5.1 | verified | `xades levels` reads them at the DSS tag at run time, outside the repository: `xades-lta-valid` meets B-T and copied tokens are rejected. Its last archive TSA has no status in the document, so B-LT and B-LTA stop at `NoSource` (EN 319 132-1 §6.3(x)). `xades-t-with-tsvd` carries an unsorted certificate SET OF: `TimestampTokenEncoding::Declared` refuses it because an unmarked token is DER (§5.1.3), `TimestampTokenEncoding::Ber` reads it as RFC 5652 BER | | OCSP responder outside the issuer | verified | Counts only as `Inputs::responders` configures it for that issuer (RFC 6960 §4.2.2.2) | | `RenewedDigestsV2` over a signed Manifest | verified | B-LTA with SHA-512 renewal of a SHA-256 Manifest reference; a wrong new digest or reference digest stops the level with `Outcome::Renewal` (EN 319 132-1 §5.5.3). No independent validator checked it | | Caller-supplied CRLs and OCSP responses | verified | They answer status but do not count as incorporated, so the level stays unmet | @@ -240,7 +240,7 @@ certificate engine, C14N, transform or XAdES implementation. Existing work was i No duplicate backlog was created. Trust in this package means only the explicitly supplied synthetic root at the fixed test instant. No legal qualification follows from that path -or from `all_root_requirements_met()`. +or from `all_requirements_met()`. ## Intended collaboration diff --git a/interop/xades/SHA256SUMS b/interop/xades/SHA256SUMS index 8b9fee30..22a510b7 100644 --- a/interop/xades/SHA256SUMS +++ b/interop/xades/SHA256SUMS @@ -1,7 +1,7 @@ e6cc48410ec8597478dae1df8bda75fe5323a818c3f8f4261a927630f8b468a3 interop/xades/.gitattributes c949c65b59cd74cc712fab76947b07d015627f40cf96d90eb28da66ff1f45000 interop/xades/COMMENT-DRAFT.md c56a60f65166e58b42851a11a9b25d2c4de9ee45217cc1e1925c01501fa8f08d interop/xades/PROVENANCE.md -0838032bc4bdd7cb5545bdff670924b7495a1de61c4d27801cb30a5197868d66 interop/xades/README.md +6debeb57b5f1ff1a855a52014802e2c07a026f7ddb9adba64a7fb8337b563a62 interop/xades/README.md 3dbdfc423c8c35aaa62ef121e3c3fc18e7d83fa5b027805db50fab8907257985 interop/xades/cases.json a7884394d334880f0a071bfd4b6a19aba70af84fe84075eb4b90a9ee9894f25e interop/xades/dss/pom.xml 569e9381ef81ea2db35192e3be9cc81dfd87b6c8104c25f09d4c18f7311957bf interop/xades/dss/src/main/java/BindingProbe.java diff --git a/src/policy.rs b/src/policy.rs index f5f59fea..b2161e0b 100644 --- a/src/policy.rs +++ b/src/policy.rs @@ -1362,6 +1362,18 @@ pub enum DetachedDigestAttestation { Accepted, } +/// How the RFC 3161 tokens of a signature are read. +#[cfg(feature = "xmldsig")] +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub enum TimestampTokenEncoding { + /// Each token holds to its declared encoding, DER when it declares none + /// (EN 319 132-1 §5.1.3). + #[default] + Declared, + /// RFC 5652 BER. A level then asserts nothing about EN 319 132-1 §5.1.3. + Ber, +} + /// Immutable policy snapshot for `XMLDSig` verification. #[cfg(feature = "xmldsig")] #[derive(Debug, Clone, Default)] @@ -1397,6 +1409,8 @@ pub struct VerificationPolicy { pub manifest_processing: ManifestProcessing, /// Whether a caller-attested digest may complete a detached Reference. pub detached_digest_attestation: DetachedDigestAttestation, + /// How the signature's timestamp tokens are read. + pub timestamp_token_encoding: TimestampTokenEncoding, /// XML parser rules. pub xml: XmlInputPolicy, /// Resource ceilings. diff --git a/src/policy/profiles/composition.rs b/src/policy/profiles/composition.rs index 5dd1f8a3..20da5f76 100644 --- a/src/policy/profiles/composition.rs +++ b/src/policy/profiles/composition.rs @@ -3,8 +3,8 @@ use crate::policy::{ CertificateSignatureAlgorithms, DetachedDigestAttestation, DsaKeyPolicy, HmacPolicy, KemContentAuthentication, KeyDerivationAlgorithm, KeyEstablishmentPolicy, KeySourcePolicy, KeyTrustPolicy, ManifestProcessing, PolicyViolation, ResourcePolicy, RsaKeyPolicy, - RsaPssPermission, SigningPolicy, TransformPolicy, UriPolicy, VerificationPolicy, - VerificationTrustMode, XmlInputPolicy, + RsaPssPermission, SigningPolicy, TimestampTokenEncoding, TransformPolicy, UriPolicy, + VerificationPolicy, VerificationTrustMode, XmlInputPolicy, }; #[cfg(feature = "xmlenc")] use crate::policy::{ @@ -503,10 +503,23 @@ fn verification( a.detached_digest_attestation, b.detached_digest_attestation, ), + timestamp_token_encoding: token_encoding( + a.timestamp_token_encoding, + b.timestamp_token_encoding, + ), xml: xml(a.xml, b.xml), resources: resources(&a.resources, &b.resources), }) } +/// BER is read only when both layers read it. +fn token_encoding(a: TimestampTokenEncoding, b: TimestampTokenEncoding) -> TimestampTokenEncoding { + if a == TimestampTokenEncoding::Ber && b == TimestampTokenEncoding::Ber { + TimestampTokenEncoding::Ber + } else { + TimestampTokenEncoding::Declared + } +} + /// A caller-attested digest is accepted only when both layers accept it. fn attestation( a: DetachedDigestAttestation, diff --git a/src/xmldsig/pkix.rs b/src/xmldsig/pkix.rs index 9ae61957..1deb8775 100644 --- a/src/xmldsig/pkix.rs +++ b/src/xmldsig/pkix.rs @@ -1394,6 +1394,65 @@ impl structured_pkix::path::Verify for CertificatePathVerifier<'_, ' } } +/// CRL and OCSP signature checks. A responder's authority never lifts the +/// operation's key-strength policy, which no certificate path reaches here: the +/// signing certificate is a path's target, or has no path at all. +pub struct RevocationVerifier<'p> { + signatures: ProviderVerifier<'p>, + rsa_keys: crate::policy::RsaKeyPolicy, + dsa_keys: crate::policy::DsaKeyPolicy, + /// Account that reads the signing key for the strength checks. + certificates: CertificateSession, +} + +impl<'p> RevocationVerifier<'p> { + pub(crate) fn new( + provider: &'p dyn crate::provider::CryptoProvider, + trust: &'p crate::policy::KeyTrustPolicy, + certificates: CertificateSession, + ) -> Self { + Self { + signatures: ProviderVerifier { + provider, + allowed: trust.certificate_signature_algorithms.as_ref(), + }, + rsa_keys: trust.rsa_keys, + dsa_keys: trust.dsa_keys, + certificates, + } + } +} + +impl structured_pkix::path::Verify for RevocationVerifier<'_> { + type Error = X509ChainError; + + fn verify( + &self, + algorithm: &structured_pkix::algorithm::AlgorithmIdentifier<'_>, + key: structured_pkix::path::WorkingKey<'_>, + signed: &[u8], + signature: structured_pkix::signature::SignatureValue<'_>, + execution: &W, + ) -> Result { + self.signatures.verify_with_key_check( + algorithm, + key, + signed, + signature, + execution, + |effective| { + super::x509::validate_issuer_spki_policy( + effective, + 0, + self.rsa_keys, + self.dsa_keys, + &self.certificates, + ) + }, + ) + } +} + /// Key family of a standalone `SubjectPublicKeyInfo` algorithm identifier. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(crate) enum SpkiAlgorithm { @@ -2564,6 +2623,36 @@ mod tests { .expect("test encoding") } + #[test] + fn a_revocation_signature_obeys_the_key_strength_policy() { + // A configured OCSP responder has no certificate path, so this check is + // the only one that reads its key: a weak key must not sign status. + let bytes = pem::parse(include_bytes!("../../tests/fixtures/keys/cacert.pem")) + .expect("CA certificate PEM") + .into_contents(); + let session = CertificateSession::new(&ResourcePolicy::default()); + let parsed = session.read(&bytes).expect("RSA certificate"); + let mut trust = crate::policy::KeyTrustPolicy::default(); + trust.rsa_keys.minimum_modulus_bits = 8192; + let verifier = RevocationVerifier::new( + crate::provider::default_provider(), + &trust, + CertificateSession::new(&ResourcePolicy::default()), + ); + let result = structured_pkix::path::Verify::verify( + &verifier, + &parsed.tbs().signature(), + WorkingKey::standing(parsed.tbs().public_key()), + parsed.signed_bytes(), + parsed.signature_value(), + session.memory(), + ); + assert!( + matches!(result, Err(X509ChainError::KeyPolicy { .. })), + "{result:?}" + ); + } + #[test] fn discovery_defers_a_dsa_key_whose_parameters_need_inheritance() { // RFC 5280 6.1.4(e) cannot be evaluated from this isolated pool edge. diff --git a/src/xmldsig/verify/session/lookup.rs b/src/xmldsig/verify/session/lookup.rs index 35f1759d..c140ddcc 100644 --- a/src/xmldsig/verify/session/lookup.rs +++ b/src/xmldsig/verify/session/lookup.rs @@ -208,19 +208,21 @@ impl VerifiedSession<'_, '_, '_, W> { super::super::super::pkix::path_bounds(self.context.policy.key_trust.max_x509_chain_depth) } - /// CRL and OCSP signature checks through this operation's provider and - /// certificate-signature permissions. Any key it is given is checked as - /// supplied: the caller establishes that key's authority. - pub fn revocation_verifier(&self) -> super::super::super::pkix::ProviderVerifier<'_> { - super::super::super::pkix::ProviderVerifier { - provider: self.context.provider, - allowed: self - .context - .policy - .key_trust - .certificate_signature_algorithms - .as_ref(), - } + /// How this operation's compiled policy reads timestamp tokens. + pub fn timestamp_token_encoding(&self) -> crate::policy::TimestampTokenEncoding { + self.context.policy.timestamp_token_encoding + } + + /// CRL and OCSP signature checks through this operation's provider, + /// certificate-signature permissions and RSA/DSA key policy. Any key that + /// passes them is otherwise checked as supplied: the caller establishes + /// that key's authority. + pub fn revocation_verifier(&self) -> super::super::super::pkix::RevocationVerifier<'_> { + super::super::super::pkix::RevocationVerifier::new( + self.context.provider, + &self.context.policy.key_trust, + super::super::super::pkix::CertificateSession::new(&self.context.policy.resources), + ) } /// Certificate-path signature checks for `chain` and `anchor` through this diff --git a/tools/xml-sec-tools/src/xades/levels.rs b/tools/xml-sec-tools/src/xades/levels.rs index fcf4cfcd..e5ebfd7f 100644 --- a/tools/xml-sec-tools/src/xades/levels.rs +++ b/tools/xml-sec-tools/src/xades/levels.rs @@ -237,6 +237,22 @@ impl Levels<'_> { /// As [`Self::ocsp`], signed by `responder`. fn ocsp_from(&self, responder: &str, subject: &str, by_key: bool) -> Result, String> { + self.ocsp_response(responder, subject, by_key, &[]) + } + + /// As [`Self::ocsp_from`], with no certificates: RFC 6960 §4.2.1 lets a + /// responder omit them. + fn ocsp_uncertified(&self, responder: &str, subject: &str) -> Result, String> { + self.ocsp_response(responder, subject, false, &["-resp_no_certs"]) + } + + fn ocsp_response( + &self, + responder: &str, + subject: &str, + by_key: bool, + options: &[&str], + ) -> Result, String> { let (signer, signer_key) = (format!("{responder}.pem"), format!("{responder}.key")); let certificate = format!("{subject}.pem"); let serial = self.serial(subject)?; @@ -279,6 +295,7 @@ impl Levels<'_> { if by_key { respond.push("-resp_key_id"); } + respond.extend(options); self.openssl(&respond)?; self.read(&response) } @@ -290,20 +307,28 @@ impl Levels<'_> { /// An RFC 3161 token over `input`, issued under this TSA configuration. fn token_under(&self, input: &[u8], config: &str) -> Result { + self.token_requested(input, config, &["-cert"]) + } + + /// As [`Self::token`], without the signing certificate: RFC 3161 §2.4.1 + /// includes it only when the request asks. + fn token_uncertified(&self, input: &[u8]) -> Result { + self.token_requested(input, TSA_CONFIG, &[]) + } + + fn token_requested( + &self, + input: &[u8], + config: &str, + options: &[&str], + ) -> Result { self.write("tsa.input", input)?; self.write("tsa.serial", "01\n")?; self.write("tsa.cnf", config)?; - self.openssl(&[ - "ts", - "-query", - "-data", - "tsa.input", - "-sha256", - "-cert", - "-no_nonce", - "-out", - "tsa.tsq", - ])?; + let mut query = vec!["ts", "-query", "-data", "tsa.input", "-sha256"]; + query.extend(options); + query.extend(["-no_nonce", "-out", "tsa.tsq"]); + self.openssl(&query)?; self.openssl(&[ "ts", "-reply", @@ -886,6 +911,34 @@ fn write_status_variants( &certificate_values(generator, &["issuer", "root"])?, ), )?; + let uncertified = levels.ocsp_uncertified("outsider", "signer")?; + let uncertified_tsa = levels.ocsp_uncertified("outsider", "tsa")?; + variant( + "b-lt-uncertified-responder.xml", + material + .replace(&good, &revocation_values(&[root_crl], &[&uncertified])) + .replace( + &revocation_values(&[issuer_crl, root_crl], &[]), + &revocation_values(&[root_crl], &[&uncertified_tsa]), + ) + .replace( + &certificate_values(generator, &["issuer", "root", "responder"])?, + &certificate_values(generator, &["issuer", "root"])?, + ), + )?; + let value = element(signed, "")?; + let token = levels.token_uncertified(&canonical(generator, &value)?)?; + let stamp = format!( + r#"{}"#, + stamped(&token) + ); + let start = material + .find("") + .ok_or("no values")?; + variant( + "b-lt-uncertified-token.xml", + format!("{stamp}{}", &material[start..]), + )?; let revoked = levels.crl_revoking("issuer", "signer")?; variant( "b-lt-conflicting-status.xml", From aeb7ab0854a9f92a18b86d7f6a17d41dd08e287a Mon Sep 17 00:00:00 2001 From: Dmitry Prudnikov Date: Sun, 1 Nov 2026 00:55:27 +0200 Subject: [PATCH 4/4] fix(xades): build tests without std and report token encoding - The path unit tests and the WebAssembly smoke follow the adapter API without std and without the removed token profile input. - Moving to the Declared token encoding reports as restrictive, as profile composition already treats it. A regression test covers both directions. --- crates/xml-sec-config/src/settings.rs | 20 +++++++++++++++++++- crates/xml-sec-xades/src/path/tests.rs | 4 +++- tests/wasm-smoke/src/lib.rs | 3 +-- 3 files changed, 23 insertions(+), 4 deletions(-) diff --git a/crates/xml-sec-config/src/settings.rs b/crates/xml-sec-config/src/settings.rs index 8347f59b..eacfe6ee 100644 --- a/crates/xml-sec-config/src/settings.rs +++ b/crates/xml-sec-config/src/settings.rs @@ -1360,7 +1360,8 @@ fn direction(field: &str, old: Option<&Value>, new: Option<&Value>) -> Direction | "Process" | "RequireAuthenticatedCipher" | "ExactOnly" - | "Forbidden", + | "Forbidden" + | "Declared", ), ) | (Some("AllSupported"), Some("SecureSupported")) => Restrictive, @@ -1579,4 +1580,21 @@ mod tests { Direction::Relaxing ); } + + #[test] + fn holding_timestamp_tokens_to_their_declared_encoding_is_restrictive() { + // Composition treats `Declared` as the stricter reading; a rollout + // report must not call the same change a relaxation. + let field = "verification.timestamp_token_encoding"; + let declared = Value::String("Declared".into()); + let ber = Value::String("Ber".into()); + assert_eq!( + direction(field, Some(&ber), Some(&declared)), + Direction::Restrictive + ); + assert_eq!( + direction(field, Some(&declared), Some(&ber)), + Direction::Relaxing + ); + } } diff --git a/crates/xml-sec-xades/src/path/tests.rs b/crates/xml-sec-xades/src/path/tests.rs index 2afdd7eb..06a2bcda 100644 --- a/crates/xml-sec-xades/src/path/tests.rs +++ b/crates/xml-sec-xades/src/path/tests.rs @@ -1,5 +1,7 @@ use super::signers; -use std::sync::Arc; +use alloc::sync::Arc; +use alloc::vec; +use alloc::vec::Vec; use structured_asn1::memory::{Memory, MemoryAccount}; use xml_sec::XmlDocument; use xml_sec::policy::{Instant, VerificationPolicy}; diff --git a/tests/wasm-smoke/src/lib.rs b/tests/wasm-smoke/src/lib.rs index 3baf741c..7a53ba94 100644 --- a/tests/wasm-smoke/src/lib.rs +++ b/tests/wasm-smoke/src/lib.rs @@ -19,7 +19,7 @@ use xml_sec::xmldsig::{ DefaultKeyResolver, DsigStatus, FailureReason, KeyResolverConfig, VerificationRequest, VerifyContext, verify_signature_with_pem_key, with_verified_request, }; -use xml_sec_xades::{Inputs, Outcome, Requirements, TokenProfile, validate}; +use xml_sec_xades::{Inputs, Outcome, Requirements, validate}; /// A donor SAML 2.0 response signed by its identity provider. const SIGNED_RESPONSE: &str = include_str!("../../fixtures/saml/response_signed_by_idp_ecdsa.xml"); @@ -80,7 +80,6 @@ fn archival_level(xml: &str) -> Option { with_verified_request(&document, &context, &request, &account, |session| { let inputs = Inputs { requirements: Requirements::Archival, - token_profile: TokenProfile::Etsi, anchors, certificates: &[], utc: &utc,