From 4eb3768c49b5bc503d310b081b9b8010e9aa832e Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Fri, 11 Sep 2026 03:27:23 +0200 Subject: [PATCH 1/8] feat(seal): read EU Trusted Lists, unverified --- Cargo.lock | 10 +- crates/dpp-common/src/outbound.rs | 108 +- crates/dpp-seal/Cargo.toml | 19 + crates/dpp-seal/src/eideasy/client.rs | 6 + crates/dpp-seal/src/lib.rs | 1 + crates/dpp-seal/src/local/sealer.rs | 18 +- crates/dpp-seal/src/trustlist/fetch.rs | 84 + crates/dpp-seal/src/trustlist/mod.rs | 60 + crates/dpp-seal/src/trustlist/model.rs | 128 ++ crates/dpp-seal/src/trustlist/parse.rs | 236 +++ crates/dpp-seal/src/trustlist/tests.rs | 299 ++++ .../tests/fixtures/fi-trusted-list.xml | 1349 +++++++++++++++++ 12 files changed, 2284 insertions(+), 34 deletions(-) create mode 100644 crates/dpp-seal/src/trustlist/fetch.rs create mode 100644 crates/dpp-seal/src/trustlist/mod.rs create mode 100644 crates/dpp-seal/src/trustlist/model.rs create mode 100644 crates/dpp-seal/src/trustlist/parse.rs create mode 100644 crates/dpp-seal/src/trustlist/tests.rs create mode 100644 crates/dpp-seal/tests/fixtures/fi-trusted-list.xml diff --git a/Cargo.lock b/Cargo.lock index fd037db8..fb52be69 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2545,12 +2545,14 @@ dependencies = [ "cms", "const-oid 0.9.6", "der", + "dpp-common", "dpp-domain", "hex", "hmac 0.13.0", "p256", "rcgen", "reqwest", + "roxmltree", "serde", "serde_json", "sha2 0.11.0", @@ -5441,6 +5443,12 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "roxmltree" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97" + [[package]] name = "rqrr" version = "0.11.0" @@ -6379,7 +6387,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" dependencies = [ "fastrand", - "getrandom 0.3.4", + "getrandom 0.4.3", "once_cell", "rustix", "windows-sys 0.61.2", diff --git a/crates/dpp-common/src/outbound.rs b/crates/dpp-common/src/outbound.rs index b9137141..f93983f2 100644 --- a/crates/dpp-common/src/outbound.rs +++ b/crates/dpp-common/src/outbound.rs @@ -148,35 +148,13 @@ pub fn guarded_client() -> Client { /// exceeded `max_bytes` or did not parse. Every variant is fail-closed: a caller /// must never treat any of them as a pass. pub async fn fetch_json(client: &Client, url: &str, max_bytes: usize) -> Result { - // Guard before the request, not after — and before any DNS the client would - // do, so a refusal costs nothing. - // // The guard hands back the addresses it approved, and the request is pinned - // to them (see `pinned_client`). Discarding them and passing only the URL — - // which is what `assert_public_target` does — leaves the client to resolve - // the name a second time, and a zero-TTL record alternating a public and an - // internal answer passes the first resolution and connects on the second. - let target = url_guard::resolve_public_target(url) - .await - .map_err(FetchError::Refused)?; - - let pinned; - let client = if target.is_literal() { - // No name, nothing to rebind — reuse the shared client and its pool. - client - } else { - pinned = pinned_client(&target)?; - &pinned - }; - - let resp = client - .get(url) - .send() - .await - .map_err(|e| FetchError::Unreachable(e.to_string()))?; - if !resp.status().is_success() { - return Err(FetchError::Unreachable(format!("HTTP {}", resp.status()))); - } + // to them (see `guarded_get` and `pinned_client`). Discarding them and + // passing only the URL — which is what `assert_public_target` does — leaves + // the client to resolve the name a second time, and a zero-TTL record + // alternating a public and an internal answer passes the first resolution + // and connects on the second. + let resp = guarded_get(client, url).await?; read_capped_json(resp, max_bytes).await } @@ -245,6 +223,15 @@ fn pinned_client(target: &url_guard::CheckedTarget) -> Result Result { + let buf = read_capped(resp, max_bytes).await?; + serde_json::from_slice(&buf).map_err(|e| FetchError::Body(e.to_string())) +} + +/// Read at most `max_bytes` of the body, refusing rather than truncating. +/// +/// Shared by [`fetch_json`] and [`fetch_text`] so the cap cannot be enforced two +/// ways — the reason this is a function and not two loops. +async fn read_capped(resp: reqwest::Response, max_bytes: usize) -> Result, FetchError> { let mut buf: Vec = Vec::new(); let mut stream = resp.bytes_stream(); while let Some(chunk) = stream.next().await { @@ -256,7 +243,70 @@ async fn read_capped_json(resp: reqwest::Response, max_bytes: usize) -> Result Result { + let resp = guarded_get(client, url).await?; + let buf = read_capped(resp, max_bytes).await?; + String::from_utf8(buf).map_err(|e| FetchError::Body(format!("body is not UTF-8: {e}"))) +} + +/// Guard `url`, pin the client to the approved addresses, and `GET` it. +/// +/// The shared half of [`fetch_json`] and [`fetch_text`]. Extracted so the +/// guard-then-pin sequence has one implementation: the whole point of pinning is +/// that the address checked is the address connected to, and a second copy of +/// that sequence is a second chance to get it subtly wrong. +async fn guarded_get(client: &Client, url: &str) -> Result { + // Guard before the request, not after — and before any DNS the client would + // do, so a refusal costs nothing. + let target = url_guard::resolve_public_target(url) + .await + .map_err(FetchError::Refused)?; + + let pinned; + let client = if target.is_literal() { + client + } else { + pinned = pinned_client(&target)?; + &pinned + }; + + let resp = client + .get(url) + .send() + .await + .map_err(|e| FetchError::Unreachable(e.to_string()))?; + if !resp.status().is_success() { + return Err(FetchError::Unreachable(format!("HTTP {}", resp.status()))); + } + Ok(resp) } #[cfg(test)] diff --git a/crates/dpp-seal/Cargo.toml b/crates/dpp-seal/Cargo.toml index 8c2724af..32874031 100644 --- a/crates/dpp-seal/Cargo.toml +++ b/crates/dpp-seal/Cargo.toml @@ -12,6 +12,12 @@ publish = false [dependencies] dpp-domain = { workspace = true } +# For `outbound` — the one guarded HTTP path. A trusted list fetch must use it +# rather than its own client: the list of lists names 43 URLs, we do not verify +# its signature, so those URLs are attacker-influenceable in principle. That is +# precisely what the resolving SSRF guard is for. +dpp-common = { path = "../dpp-common" } + serde = { workspace = true } serde_json = { workspace = true } thiserror = { workspace = true } @@ -35,6 +41,19 @@ zeroize = { workspace = true } # `default-features = false` keeps `rsa` out of the tree: the `builder` feature # pulls it in, we sign with P-256, and `rsa` 0.9 carries RUSTSEC-2023-0071 (Marvin # timing sidechannel) with no fixed upgrade available. +# EU Trusted Lists are XML, and this parses them. A read-only DOM rather than a +# pull parser: the TS 119 612 shape is deeply nested with optional branches +# (`TSPService` -> `ServiceInformation` plus an optional `ServiceHistory` of +# instances), and a pull parser would need hand-rolled nesting state for each — +# more places for a hostile document to walk a parser into the wrong branch. +# Documents are bounded by the caller's fetch cap before they reach here, so +# holding one in memory is affordable and correctness wins. +# +# `roxmltree` forbids unsafe, has no transitive dependencies beyond its own +# tokenizer, and does no entity expansion — so the billion-laughs class of +# attack does not apply. +roxmltree = "0.20" + cms = { version = "0.2", default-features = false } x509-cert = "0.2" der = "0.7" diff --git a/crates/dpp-seal/src/eideasy/client.rs b/crates/dpp-seal/src/eideasy/client.rs index c9507d45..de6ac3de 100644 --- a/crates/dpp-seal/src/eideasy/client.rs +++ b/crates/dpp-seal/src/eideasy/client.rs @@ -204,6 +204,12 @@ impl SealBackend for EideasyClient { // so reaching here means the request named the profile's own level. // The independent reading lives in `cades::evidenced_level`, and the // two disagreeing is the downgrade the drain alarms on. + // + // A profile this build cannot classify empties `supported_levels` + // entirely, so every request against it is refused before any + // billable call — there is no path here that would have to guess a + // level, which is exactly the misdescription that refusal exists to + // prevent. conformance_level: Some(req.conformance_level), sealed_at: Utc::now(), placeholder: false, diff --git a/crates/dpp-seal/src/lib.rs b/crates/dpp-seal/src/lib.rs index f018c057..b71289b6 100644 --- a/crates/dpp-seal/src/lib.rs +++ b/crates/dpp-seal/src/lib.rs @@ -46,6 +46,7 @@ pub mod eideasy; pub mod error; pub mod ghost; pub mod local; +pub mod trustlist; pub use adapter::QtspSealAdapter; pub use backend::SealBackend; diff --git a/crates/dpp-seal/src/local/sealer.rs b/crates/dpp-seal/src/local/sealer.rs index 456147bd..0b707a04 100644 --- a/crates/dpp-seal/src/local/sealer.rs +++ b/crates/dpp-seal/src/local/sealer.rs @@ -209,10 +209,20 @@ impl SealBackend for LocalIdentity { format: SealFormat::Cades, seal_value: base64::engine::general_purpose::STANDARD.encode(&der), signing_cert_ref: Some(self.cert_thumbprint()), - // The requested level, per the field's contract. `capabilities()` - // advertises `BaselineB` alone and the adapter checks `can_produce` - // first, so the only request that reaches here asked for `BaselineB` - // — which is also what these bytes carry. + // The **requested** level, which is what this field records. Core's + // own kit fails an envelope whose stored level disagrees with the + // request (`seal.misrecorded_level`), and the field's doc is explicit + // that it is a record of what was asked for rather than proof of what + // arrived. + // + // That is not the same as trusting it. `capabilities()` advertises + // `BaselineB` alone and the adapter checks `can_produce` first, so the + // only request that reaches here asked for `BaselineB` — which is also + // what these bytes carry. If that guard ever stopped working, echoing + // the request would record a level the bytes do not have; what catches + // that is `cades::evidenced_level`, read independently by the drain, + // which alarms on the disagreement rather than letting either side + // vouch for itself. conformance_level: Some(req.conformance_level), sealed_at: Utc::now(), // Not a placeholder: these bytes verify. Legal standing is the trust diff --git a/crates/dpp-seal/src/trustlist/fetch.rs b/crates/dpp-seal/src/trustlist/fetch.rs new file mode 100644 index 00000000..5cfea366 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/fetch.rs @@ -0,0 +1,84 @@ +//! Retrieving trusted lists over the guarded outbound path. + +use dpp_common::outbound::{FetchError, fetch_text, guarded_client}; + +use super::model::{TrustedListPointer, UnverifiedTrustedList}; +use super::parse::{parse_lotl, parse_trusted_list}; +use crate::error::SealError; + +/// Where the Commission publishes the list of trusted lists. +/// +/// Regulation (EU) No 910/2014 Art. 22(3): the Commission makes available the +/// information Member States notify, "through a secure channel to an +/// authenticated website in a signed or sealed form suitable for automated +/// processing". +/// +/// A constant rather than configuration. There is exactly one list of lists, its +/// address is fixed by the Commission, and making it settable would turn the +/// root of the whole trust hierarchy into something an environment variable can +/// redirect — which, with the signature unverified, is the entire trust model. +pub const EU_LOTL_URL: &str = "https://ec.europa.eu/tools/lotl/eu-lotl.xml"; + +/// Body cap for a trusted list fetch. +/// +/// Measured rather than guessed: the list of lists is about 480 KiB, and +/// national lists have been seen from roughly 140 KiB to over 600 KiB. One +/// mebibyte leaves room for growth while still bounding what a hostile response +/// can make this process allocate. +/// +/// [`dpp_common::outbound::DEFAULT_MAX_BODY`] is 256 KiB and would refuse most +/// of these documents, which is why the cap is stated here rather than defaulted. +pub const MAX_TRUSTED_LIST_BYTES: usize = 1024 * 1024; + +fn fetch_failed(url: &str, e: &FetchError) -> SealError { + SealError::Backend(format!("cannot fetch the trusted list at {url}: {e}")) +} + +/// Fetch and parse the EU list of trusted lists. +/// +/// Returns every pointer it carries, including the non-national ones — filtering +/// is the caller's, because which pointers matter depends on the question. See +/// [`national_pointers`] for the usual filter. +/// +/// # Errors +/// +/// [`SealError::Backend`] when the fetch is refused by the outbound guard, the +/// document is unreachable or over the cap, or it does not parse. +pub async fn fetch_lotl_pointers() -> Result, SealError> { + let client = guarded_client(); + let xml = fetch_text(&client, EU_LOTL_URL, MAX_TRUSTED_LIST_BYTES) + .await + .map_err(|e| fetch_failed(EU_LOTL_URL, &e))?; + parse_lotl(&xml) +} + +/// The pointers that name a scheme territory — the national trusted lists. +/// +/// The rest are the list of lists' own historical pivot documents, which record +/// how it changed over time and are not trusted lists. They parse without error +/// and yield no providers, so fetching them wastes a request and produces an +/// empty result that reads like a country with no trust services. +#[must_use] +pub fn national_pointers(pointers: &[TrustedListPointer]) -> Vec<&TrustedListPointer> { + pointers.iter().filter(|p| p.territory.is_some()).collect() +} + +/// Fetch and parse one national trusted list. +/// +/// **The result is unverified** — see [`UnverifiedTrustedList`] for exactly what +/// that excludes. This function fetches over TLS through the guarded outbound +/// path and parses what comes back; it does not check the document's XAdES +/// signature, so it establishes what a server answered and not what a Member +/// State published. +/// +/// # Errors +/// +/// [`SealError::Backend`] when the fetch is refused, unreachable, over the cap, +/// or the document does not parse. +pub async fn fetch_trusted_list(url: &str) -> Result { + let client = guarded_client(); + let xml = fetch_text(&client, url, MAX_TRUSTED_LIST_BYTES) + .await + .map_err(|e| fetch_failed(url, &e))?; + parse_trusted_list(&xml) +} diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs new file mode 100644 index 00000000..49035de3 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -0,0 +1,60 @@ +//! Reading EU Trusted Lists — what they say, never that it is true. +//! +//! Regulation (EU) No 910/2014 **Art. 22** requires each Member State to publish +//! a trusted list "in a form suitable for automated processing", and the +//! Commission to publish the list of those lists. That is what makes qualified +//! status a fact software can look up rather than a claim it has to accept from +//! a vendor. The vocabulary those lists are written in lives in +//! [`dpp_domain::trusted_list`]; this module fetches and parses the documents. +//! +//! # 🚩 Nothing here is verified, and the ceiling that puts on it +//! +//! A trusted list is an **XAdES-signed** XML document. The signature, checked +//! against the scheme operator's certificate, is what makes it evidence rather +//! than a file from a web server. **This module does not check it.** +//! +//! Verifying one needs XML Signature with canonicalisation, which has no mature +//! Rust implementation — the EU's own validator is a Java application. Writing +//! one is a serious piece of work in its own right, and canonicalisation is +//! exactly where subtle signature-verification bugs live. So it is not attempted +//! here, and the gap is named rather than glossed. +//! +//! What follows from that is a hard boundary, and it is built into the type +//! names: [`UnverifiedTrustedList`] is what parsing produces, and nothing in +//! this crate turns it into a verdict. +//! +//! **Sound uses.** Answering *"which service types is this provider listed +//! under, and with what status?"* — for a trust report, or to put a precise +//! question to a provider and its supervisory body. For the Art. 39a check +//! ([`TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT`](dpp_domain::trusted_list::TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT)) +//! there is no other automated starting point. +//! +//! **Unsound uses.** Any compliance verdict. In particular this must not be used +//! to produce [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation), +//! which asserts the legs of Art. 32(1) were checked. An unverified document +//! cannot establish that a certificate was qualified; it can only report what +//! something claimed. +//! +//! This is the same discipline [`crate::cades`] applies to a seal's own bytes: +//! read, report, and never imply a check that did not happen. +//! +//! # Time, not the present +//! +//! Each service comes back as a [`TrustServiceHistory`](dpp_domain::trusted_list::TrustServiceHistory) +//! rather than a status, assembled by merging the current `ServiceInformation` +//! with every `ServiceHistoryInstance`. Art. 32(1)(b), applied to seals by +//! Art. 40, asks whether a provider was qualified **at the time of sealing** — +//! so a present-tense answer is the wrong answer to the question that matters, +//! in both directions. + +mod fetch; +mod model; +mod parse; +#[cfg(test)] +mod tests; + +pub use fetch::{ + EU_LOTL_URL, MAX_TRUSTED_LIST_BYTES, fetch_lotl_pointers, fetch_trusted_list, national_pointers, +}; +pub use model::{ListedProvider, ListedService, TrustedListPointer, UnverifiedTrustedList}; +pub use parse::{parse_lotl, parse_trusted_list}; diff --git a/crates/dpp-seal/src/trustlist/model.rs b/crates/dpp-seal/src/trustlist/model.rs new file mode 100644 index 00000000..589fd148 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/model.rs @@ -0,0 +1,128 @@ +//! What a trusted list says — and nothing about whether it is true. + +use dpp_domain::trusted_list::{TrustServiceHistory, TrustServiceType}; + +/// One trust service as a list describes it. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ListedService { + /// The service type URI — what kind of trust service this is. + pub service_type: TrustServiceType, + /// The service's name, in whichever language the list gave first. + /// + /// A convenience for reading a report. Never a key: names are free text, + /// are not unique, and differ between a list's language variants. + pub name: Option, + /// The present status and every earlier one, as published. + /// + /// Assembled from `ServiceInformation` (the current status and its + /// `StatusStartingTime`) together with each `ServiceHistoryInstance`. That + /// merge is the reason this is a history rather than a status: it is what + /// lets a caller ask what was true when a seal was made, rather than what is + /// true now. + pub history: TrustServiceHistory, + /// The base64 DER certificates in `ServiceDigitalIdentity`, verbatim. + /// + /// Kept as published rather than parsed. This module has no business + /// deciding what a certificate means, and a parse here would be a second + /// place for X.509 handling to disagree with [`crate::cades`]. + pub certificates: Vec, +} + +/// One trust service provider, and the services it is listed for. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct ListedProvider { + /// The provider's name as published. + pub name: Option, + /// Its services. + pub services: Vec, +} + +impl ListedProvider { + /// The services of a given type. + /// + /// The lookup the Art. 39a question needs: a provider may be listed many + /// times over, and holding one service type says nothing about holding + /// another. + pub fn services_of_type<'a>( + &'a self, + service_type: &'a str, + ) -> impl Iterator + 'a { + self.services + .iter() + .filter(move |s| s.service_type.as_str() == service_type) + } +} + +/// A parsed trusted list. **Nothing here has been verified.** +/// +/// The name carries the warning because the type is the last place a caller +/// looks before trusting what is inside it. +/// +/// # What "unverified" means, precisely +/// +/// A trusted list is an XAdES-signed XML document, and its signature is what +/// makes it evidence rather than a file from a web server. **This crate does not +/// check that signature**, so everything in this struct is *what a server +/// answered*, not *what a Member State published*. +/// +/// The distinction is not academic. Regulation (EU) No 910/2014 Art. 22 makes +/// trusted lists authoritative precisely because they are signed and published +/// by a named scheme operator. Strip the signature check and what remains has +/// the shape of authority without the substance — which is the failure mode +/// [`crate::cades`] is arranged to avoid, and this type is named to avoid it in +/// the same way. +/// +/// # What it is therefore good for +/// +/// Reading. Answering *"which service types is this provider listed under, and +/// with what status?"* so a human can put the question to the provider and to +/// the supervisory body. That is a real need — the Art. 39a check has no other +/// automated starting point — and it is honest work for an unverified document +/// fetched over TLS from a known host. +/// +/// # What it must never be used for +/// +/// A compliance verdict. In particular it must not be used to produce +/// [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation), +/// which asserts that the legs of Art. 32(1) were checked. Establishing +/// qualified status needs the signature verified against the scheme operator's +/// certificate, and that is a separate piece of work that does not exist yet. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct UnverifiedTrustedList { + /// The `SchemeTerritory` — the two-letter country code, where given. + pub territory: Option, + /// The providers the list carries. + pub providers: Vec, +} + +impl UnverifiedTrustedList { + /// Every provider listed for `service_type`, paired with those services. + /// + /// Skips providers with no such service, so an empty result means "nobody in + /// this list is listed for that service type" — which for + /// [`TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT`] is the common and + /// interesting answer. + pub fn providers_offering<'a>( + &'a self, + service_type: &'a str, + ) -> impl Iterator)> + 'a { + self.providers.iter().filter_map(move |p| { + let services: Vec<_> = p.services_of_type(service_type).collect(); + (!services.is_empty()).then_some((p, services)) + }) + } +} + +/// A pointer from the list of trusted lists to one national list. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct TrustedListPointer { + /// Where the list is published. + pub location: String, + /// The `SchemeTerritory` this pointer is for, where the LOTL gave one. + /// + /// `None` for the pointers that are not national lists — the LOTL also + /// points at its own historical pivot documents, which carry no territory + /// and are not trusted lists. Filtering on this is how a caller tells them + /// apart; see [`super::parse::parse_lotl`]. + pub territory: Option, +} diff --git a/crates/dpp-seal/src/trustlist/parse.rs b/crates/dpp-seal/src/trustlist/parse.rs new file mode 100644 index 00000000..8b972eec --- /dev/null +++ b/crates/dpp-seal/src/trustlist/parse.rs @@ -0,0 +1,236 @@ +//! TS 119 612 XML into [`UnverifiedTrustedList`]. + +use chrono::{DateTime, Utc}; +use dpp_domain::trusted_list::{ + TrustServiceHistory, TrustServiceStatus, TrustServiceStatusPeriod, TrustServiceType, +}; +use roxmltree::{Document, Node}; + +use super::model::{ListedProvider, ListedService, TrustedListPointer, UnverifiedTrustedList}; +use crate::error::SealError; + +fn malformed(what: impl std::fmt::Display) -> SealError { + SealError::Backend(format!("cannot read the trusted list: {what}")) +} + +/// Find direct children by **local** name, ignoring the namespace prefix. +/// +/// Every lookup in this module goes through here, and the reason is +/// interoperability rather than convenience. Twenty-seven Member States publish +/// these documents with their own tooling: the same element appears as +/// `ServiceStatus`, `tsl:ServiceStatus` and `ns3:ServiceStatus` across lists, +/// and one publisher changing its XML library would otherwise silently empty our +/// view of that country. +/// +/// Matching the local name is what TS 119 612 actually constrains. Matching a +/// prefix would be matching a publisher's habit. +fn children<'a, 'i>(node: Node<'a, 'i>, name: &'a str) -> impl Iterator> + 'a { + node.children() + .filter(move |c| c.is_element() && c.tag_name().name() == name) +} + +/// The first direct child with this local name. +fn child<'a, 'i>(node: Node<'a, 'i>, name: &'a str) -> Option> { + children(node, name).next() +} + +/// The trimmed text of the first direct child with this local name. +fn child_text(node: Node<'_, '_>, name: &str) -> Option { + child(node, name) + .and_then(|n| n.text()) + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(ToOwned::to_owned) +} + +/// A descendant by local-name path, first match at each step. +fn path<'a, 'i>(node: Node<'a, 'i>, names: &[&'a str]) -> Option> { + names.iter().try_fold(node, |n, name| child(n, name)) +} + +/// Parse a national trusted list. +/// +/// # Errors +/// +/// [`SealError::Backend`] when the document is not XML, or carries no +/// `TrustServiceStatusList` root. A list that parses but contains no providers +/// is **not** an error — a Member State with nothing to list publishes an empty +/// one, and turning that into a failure would make an accurate answer look like +/// an outage. +pub fn parse_trusted_list(xml: &str) -> Result { + let doc = Document::parse(xml).map_err(|e| malformed(format!("not XML: {e}")))?; + let root = doc.root_element(); + if root.tag_name().name() != "TrustServiceStatusList" { + return Err(malformed(format!( + "root element is `{}`, not `TrustServiceStatusList`", + root.tag_name().name() + ))); + } + + let territory = path(root, &["SchemeInformation"]) + .and_then(|si| child_text(si, "SchemeTerritory")) + .map(|t| t.to_uppercase()); + + let providers = child(root, "TrustServiceProviderList") + .into_iter() + .flat_map(|list| children(list, "TrustServiceProvider")) + .map(parse_provider) + .collect(); + + Ok(UnverifiedTrustedList { + territory, + providers, + }) +} + +fn parse_provider(node: Node<'_, '_>) -> ListedProvider { + let name = path(node, &["TSPInformation", "TSPName"]).and_then(|n| first_name(n)); + + let services = child(node, "TSPServices") + .into_iter() + .flat_map(|s| children(s, "TSPService")) + .map(parse_service) + .collect(); + + ListedProvider { name, services } +} + +/// The first `` in a multilingual name element. +/// +/// Lists carry one `Name` per language. Taking the first is deliberate and is +/// documented on [`ListedService::name`] as display-only — choosing by language +/// would imply these names are identifiers, and they are not. +fn first_name(node: Node<'_, '_>) -> Option { + children(node, "Name") + .find_map(|n| n.text()) + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(ToOwned::to_owned) +} + +fn parse_service(node: Node<'_, '_>) -> ListedService { + let info = child(node, "ServiceInformation"); + + let service_type = info + .and_then(|i| child_text(i, "ServiceTypeIdentifier")) + .unwrap_or_default(); + + let name = info + .and_then(|i| child(i, "ServiceName")) + .and_then(first_name); + + let certificates = info + .and_then(|i| child(i, "ServiceDigitalIdentity")) + .map(collect_certificates) + .unwrap_or_default(); + + // The current status, then every historical one. `ServiceInformation` holds + // the status in force now; `ServiceHistory` holds what came before. Merging + // them is the whole reason this returns a history — see + // `TrustServiceHistory` for why the question is asked about a moment. + let mut periods: Vec = Vec::new(); + if let Some(info) = info + && let Some(period) = parse_status_period(info) + { + periods.push(period); + } + periods.extend( + child(node, "ServiceHistory") + .into_iter() + .flat_map(|h| children(h, "ServiceHistoryInstance")) + .filter_map(parse_status_period), + ); + + ListedService { + service_type: TrustServiceType::new(service_type), + name, + history: TrustServiceHistory::new(periods), + certificates, + } +} + +/// A status and its starting time, from either a current or a historical entry. +/// +/// Both carry the same two elements, which is why one function reads both. +/// `None` when either is missing or the time is unparseable: a period with no +/// start cannot be placed on a timeline, and admitting it with a guessed time +/// would put a wrong answer into +/// [`TrustServiceHistory::status_at`](dpp_domain::trusted_list::TrustServiceHistory::status_at) +/// rather than leave a gap the caller can see. +fn parse_status_period(node: Node<'_, '_>) -> Option { + let status = child_text(node, "ServiceStatus")?; + let starting_at = child_text(node, "StatusStartingTime")?; + let starting_at = DateTime::parse_from_rfc3339(&starting_at) + .ok()? + .with_timezone(&Utc); + + Some(TrustServiceStatusPeriod { + status: TrustServiceStatus::from_uri(&status), + starting_at, + }) +} + +/// Every `X509Certificate` under a `ServiceDigitalIdentity`. +/// +/// Base64 text is whitespace-wrapped in these documents, and the whitespace is +/// not part of the value — a decoder handed the wrapped form fails. Stripping it +/// here means every consumer gets the same bytes. +fn collect_certificates(node: Node<'_, '_>) -> Vec { + children(node, "DigitalId") + .filter_map(|d| child(d, "X509Certificate")) + .filter_map(|c| c.text()) + .map(|t| t.split_whitespace().collect::()) + .filter(|s| !s.is_empty()) + .collect() +} + +/// Parse the EU list of trusted lists into its pointers. +/// +/// # Errors +/// +/// [`SealError::Backend`] when the document is not XML or is not a +/// `TrustServiceStatusList`. +/// +/// # The LOTL points at more than national lists +/// +/// It also points at its own historical *pivot* documents, which record how the +/// list of lists itself changed over time. Those carry no `SchemeTerritory`, +/// which is how they are told apart — see +/// [`TrustedListPointer::territory`](super::model::TrustedListPointer::territory). +/// Fetching one as though it were a national list would parse and yield nothing, +/// which is the quiet kind of wrong. +pub fn parse_lotl(xml: &str) -> Result, SealError> { + let doc = Document::parse(xml).map_err(|e| malformed(format!("not XML: {e}")))?; + let root = doc.root_element(); + if root.tag_name().name() != "TrustServiceStatusList" { + return Err(malformed("root element is not `TrustServiceStatusList`")); + } + + let Some(pointers) = path(root, &["SchemeInformation", "PointersToOtherTSL"]) else { + return Ok(Vec::new()); + }; + + Ok(children(pointers, "OtherTSLPointer") + .filter_map(|p| { + let location = child_text(p, "TSLLocation")?; + Some(TrustedListPointer { + territory: pointer_territory(p), + location, + }) + }) + .collect()) +} + +/// The scheme territory an `OtherTSLPointer` declares, if any. +/// +/// It is not a child element but one of a bag of typed `OtherInformation` +/// entries, so it has to be searched for rather than addressed. +fn pointer_territory(pointer: Node<'_, '_>) -> Option { + child(pointer, "AdditionalInformation")? + .descendants() + .find(|n| n.is_element() && n.tag_name().name() == "SchemeTerritory") + .and_then(|n| n.text()) + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(str::to_uppercase) +} diff --git a/crates/dpp-seal/src/trustlist/tests.rs b/crates/dpp-seal/src/trustlist/tests.rs new file mode 100644 index 00000000..bae466b9 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/tests.rs @@ -0,0 +1,299 @@ +//! Parsing trusted lists — against a real one, and against the shapes that vary. + +use super::*; +use chrono::{TimeZone as _, Utc}; +use dpp_domain::trusted_list::{TrustServiceStatus, TrustServiceType}; + +/// The Finnish trusted list, as published. +/// +/// A real document rather than one written for the test. A hand-built fixture +/// proves the parser agrees with the fixture; only a published list proves it +/// agrees with what Member States actually emit — default namespaces, prefixed +/// siblings, wrapped base64, multilingual names and all. +/// +/// It will go stale, and that is fine: every assertion below is about *parsing*, +/// never about who is currently qualified. Nothing here breaks when Finland +/// grants or withdraws a service. +const FI_TRUSTED_LIST: &str = include_str!("../../tests/fixtures/fi-trusted-list.xml"); + +#[test] +fn a_published_trusted_list_parses() { + let list = parse_trusted_list(FI_TRUSTED_LIST).expect("the published list parses"); + + assert_eq!(list.territory.as_deref(), Some("FI")); + assert!( + !list.providers.is_empty(), + "the list carries trust service providers" + ); + + let services: Vec<_> = list.providers.iter().flat_map(|p| &p.services).collect(); + assert!( + services.len() >= 20, + "and each provider's services, got {}", + services.len() + ); + + // Every service type in this list is one of the two the document actually + // contains — which is also a check that the URIs in `dpp-domain`'s constants + // match what is published, rather than what was transcribed. + let types: std::collections::BTreeSet<_> = + services.iter().map(|s| s.service_type.as_str()).collect(); + assert!(types.contains(TrustServiceType::QUALIFIED_CERTIFICATE_CA)); + assert!(types.contains(TrustServiceType::QUALIFIED_VALIDATION_SERVICE)); +} + +/// Certificates come back decodable, not as the wrapped text the XML carries. +/// +/// Base64 in these documents is line-wrapped for readability, and a decoder +/// handed the wrapped form fails. Getting this wrong would surface much later, +/// as "the trusted list has no usable certificates". +#[test] +fn published_certificates_are_stripped_of_their_wrapping() { + use base64::Engine as _; + + let list = parse_trusted_list(FI_TRUSTED_LIST).expect("parses"); + let certificate = list + .providers + .iter() + .flat_map(|p| &p.services) + .flat_map(|s| &s.certificates) + .next() + .expect("the list publishes at least one certificate"); + + assert!( + !certificate.contains(char::is_whitespace), + "no whitespace survives into the value" + ); + assert!( + base64::engine::general_purpose::STANDARD + .decode(certificate) + .is_ok(), + "and what is left decodes" + ); +} + +/// A service's current status and its history arrive as one timeline. +/// +/// The merge that makes the point-in-time question answerable. Asserted on the +/// real document because the current status and the historical instances live in +/// different elements, and a parser that read only one would still look right on +/// a list where nothing has ever changed. +#[test] +fn the_current_status_and_the_history_become_one_timeline() { + let list = parse_trusted_list(FI_TRUSTED_LIST).expect("parses"); + + let with_history = list + .providers + .iter() + .flat_map(|p| &p.services) + .find(|s| s.history.periods.len() > 1) + .expect("this list has services whose status has changed at least once"); + + let mut starts: Vec<_> = with_history + .history + .periods + .iter() + .map(|p| p.starting_at) + .collect(); + starts.sort_unstable(); + starts.dedup(); + assert_eq!( + starts.len(), + with_history.history.periods.len(), + "each period starts at a distinct moment" + ); +} + +/// A differently-prefixed document parses identically. +/// +/// Twenty-seven Member States publish these with their own tooling, and the same +/// element appears variously as `ServiceStatus`, `tsl:ServiceStatus` and +/// `ns3:ServiceStatus`. Matching a prefix instead of a local name would silently +/// empty our view of whichever country changed its XML library — a failure that +/// looks exactly like a country with no trust services. +#[test] +fn the_namespace_prefix_does_not_change_the_result() { + let default_ns = sample_list("", ""); + let prefixed = sample_list("tsl:", " xmlns:tsl=\"http://uri.etsi.org/02231/v2#\""); + + let a = parse_trusted_list(&default_ns).expect("default namespace parses"); + let b = parse_trusted_list(&prefixed).expect("prefixed parses"); + + assert_eq!(a, b, "the prefix is a publisher's habit, not meaning"); + assert_eq!(a.providers[0].services[0].history.periods.len(), 2); +} + +/// A list with no providers is an answer, not a failure. +/// +/// A Member State with nothing to list publishes an empty list. Treating that as +/// a parse error would turn an accurate answer into what looks like an outage. +#[test] +fn an_empty_list_parses_to_no_providers() { + let xml = r#" + + MT + +"#; + + let list = parse_trusted_list(xml).expect("an empty list is well-formed"); + assert_eq!(list.territory.as_deref(), Some("MT")); + assert!(list.providers.is_empty()); +} + +/// Something that is not a trusted list is refused, not parsed into an empty one. +/// +/// The dangerous failure is the quiet one: an error page or an unrelated +/// document yielding zero providers reads as "nobody is qualified there". +#[test] +fn a_document_that_is_not_a_trusted_list_is_refused() { + assert!(parse_trusted_list("404").is_err()); + assert!(parse_trusted_list("not xml at all").is_err()); + assert!( + parse_trusted_list(r#""#).is_err(), + "well-formed XML with the wrong root is still not a trusted list" + ); +} + +/// A period with no start time is dropped rather than guessed at. +/// +/// A status that cannot be placed on a timeline is worse than a missing one: it +/// would answer `status_at` with a wrong date rather than leaving a gap the +/// caller can see. +#[test] +fn a_status_without_a_start_time_is_dropped() { + let xml = r#" + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + + +"#; + + let list = parse_trusted_list(xml).expect("parses"); + assert!( + list.providers[0].services[0].history.periods.is_empty(), + "a status with no start time cannot be placed in time" + ); +} + +/// The list of lists yields its pointers, and the pivots are distinguishable. +#[test] +fn lotl_pointers_carry_their_territory_where_there_is_one() { + let xml = r#" + + + + https://example.test/TSL-FI.xml + + FI + + + + https://example.test/eu-lotl-pivot-300.xml + + +"#; + + let pointers = parse_lotl(xml).expect("parses"); + assert_eq!(pointers.len(), 2, "both pointers are returned"); + + let national = national_pointers(&pointers); + assert_eq!(national.len(), 1, "only one names a territory"); + assert_eq!(national[0].territory.as_deref(), Some("FI")); + assert_eq!(national[0].location, "https://example.test/TSL-FI.xml"); +} + +/// Looking up a service type finds only that type. +/// +/// The Art. 39a question in miniature: the qualified remote-seal-device service +/// and its non-qualified twin differ by four characters, and a provider holding +/// one says nothing about the other. +#[test] +fn a_provider_is_found_only_under_the_service_type_it_holds() { + let xml = sample_list("", ""); + let list = parse_trusted_list(&xml).expect("parses"); + + let holders: Vec<_> = list + .providers_offering(TrustServiceType::QUALIFIED_CERTIFICATE_CA) + .collect(); + assert_eq!(holders.len(), 1, "listed for the certificate service"); + + assert_eq!( + list.providers_offering(TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT) + .count(), + 0, + "and not for the Art. 39a service it does not hold" + ); +} + +/// The merged timeline answers the question Art. 32(1)(b) actually asks. +/// +/// End to end through the parser: a provider granted in 2024 and withdrawn in +/// 2026 was qualified for a seal made in 2025, and is not now. +#[test] +fn a_parsed_history_answers_what_was_true_when_the_seal_was_made() { + let list = parse_trusted_list(&sample_list("", "")).expect("parses"); + let service = &list.providers[0].services[0]; + + assert!( + service + .history + .was_granted_at(Utc.with_ymd_and_hms(2025, 6, 1, 0, 0, 0).unwrap()), + "granted when the seal was made" + ); + assert!( + !service + .history + .was_granted_at(Utc.with_ymd_and_hms(2027, 1, 1, 0, 0, 0).unwrap()), + "and withdrawn by now" + ); + assert_eq!( + service + .history + .status_at(Utc.with_ymd_and_hms(2027, 1, 1, 0, 0, 0).unwrap()), + Some(&TrustServiceStatus::Withdrawn) + ); +} + +/// A minimal but structurally faithful list: current status plus one historical +/// instance, wrapped base64, and a multilingual name. +/// +/// `prefix` and `xmlns` let the same document be rendered with a default +/// namespace or a prefixed one, which is what +/// `the_namespace_prefix_does_not_change_the_result` compares. +fn sample_list(prefix: &str, extra_ns: &str) -> String { + let p = prefix; + format!( + r#" +<{p}TrustServiceStatusList xmlns="http://uri.etsi.org/02231/v2#"{extra_ns}> + <{p}SchemeInformation><{p}SchemeTerritory>fi + <{p}TrustServiceProviderList> + <{p}TrustServiceProvider> + <{p}TSPInformation><{p}TSPName> + <{p}Name xml:lang="en">Example Trust Services Oy + <{p}Name xml:lang="fi">Example Trust Services Oy + + <{p}TSPServices><{p}TSPService> + <{p}ServiceInformation> + <{p}ServiceTypeIdentifier>http://uri.etsi.org/TrstSvc/Svctype/CA/QC + <{p}ServiceName><{p}Name xml:lang="en">Example QC CA + <{p}ServiceDigitalIdentity><{p}DigitalId><{p}X509Certificate> + TUlJRmpEQ0NC + SFNnQXdJQkFn + + <{p}ServiceStatus>http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + <{p}StatusStartingTime>2026-03-01T00:00:00Z + + <{p}ServiceHistory><{p}ServiceHistoryInstance> + <{p}ServiceTypeIdentifier>http://uri.etsi.org/TrstSvc/Svctype/CA/QC + <{p}ServiceStatus>http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + <{p}StatusStartingTime>2024-01-15T00:00:00Z + + + + +"# + ) +} diff --git a/crates/dpp-seal/tests/fixtures/fi-trusted-list.xml b/crates/dpp-seal/tests/fixtures/fi-trusted-list.xml new file mode 100644 index 00000000..fbb74cc8 --- /dev/null +++ b/crates/dpp-seal/tests/fixtures/fi-trusted-list.xml @@ -0,0 +1,1349 @@ + + + 6 + 55 + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + Finnish Transport and Communications Agency + Liikenne- ja viestintävirasto + Transport- och kommunikationsverket + + + + + P.O. Box 320 + TRAFICOM + 00059 + FI + + + + mailto:kirjaamo@traficom.fi + https://www.traficom.fi/en + + + + FI:Trusted list including information related to the qualified trust service providers which are supervised by the issuing Member State, together with information related to the qualified trust services provided by them, in accordance with the relevant provisions laid down in Regulation (EU) No 910/2014 of the European Parliament and of the Council of 23 July 2014 on electronic identification and trust services for electronic transactions in the internal market and repealing Directive 1999/93/EC. + + + https://www.traficom.fi/en + + http://uri.etsi.org/TrstSvc/TrustedList/StatusDetn/EUappropriate + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/FI + + FI + + The applicable legal framework for the present trusted list is Regulation (EU) No 910/2014 of the European Parliament and of the Council of 23 July 2014 on electronic identification and trust services for electronic transactions in the internal market and repealing Directive 1999/93/EC. + Tähän luotettuun luetteloon (trusted list) sovelletaan Euroopan parlamentin ja neuvoston asetusta (EU) N:o 910/2014, annettu 23 päivänä heinäkuuta 2014, sähköisestä tunnistamisesta ja sähköisiin transaktioihin liittyvistä luottamuspalveluista sisämarkkinoilla ja direktiivin 1999/93/EY kumoamisesta. + + 65535 + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://ec.europa.eu/tools/lotl/eu-lotl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUlistofthelists + + + EU + + + application/vnd.etsi.tsl+xml + + + + European Commission + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUlistofthelists + + + + + + 2026-08-21T06:00:00Z + + 2027-02-21T07:00:00Z + + + https://dp.trustedlist.fi/fi-tl-v6.xml + + + + + + + Digital and Population Data Services Agency + Digi- ja vaestotietovirasto + DVV + + + Population Register Centre + Vaestorekisterikeskus + VRK + NTRFI-0245437-2 + Vaestorekisterikeskus CA + Population Register Centre + Vaestorekisterikeskus + VRK + + + + + P.O.Box 123 + Helsinki + 00531 + FI + + + + mailto:kirjaamo@dvv.fi + https://www.dvv.fi/ + + + + https://dvv.fi/tietoa-virastosta + https://dvv.fi/en/about-the-agency + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK Gov. CA for Citizen Qualified Certificates + + + +MIIFjDCCBHSgAwIBAgIDAYiZMA0GCSqGSIb3DQEBBQUAMIGjMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4gUm9vdCBDQTAeFw0wMzAxMTAxMjU5MDVaFw0xOTAxMDkxMjU4MzBaMIGhMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSQwIgYDVQQLExtWYWx0aW9uIGthbnNhbGFpc3Zhcm1lbnRlZXQxNzA1BgNVBAMTLlZSSyBHb3YuIENBIGZvciBDaXRpemVuIFF1YWxpZmllZCBDZXJ0aWZpY2F0ZXMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC5Aj527olxDHOtkQQU+BG1FUs0xOy8Qw2z3NmgV7yOkYRwi/C7aAbvaye712q8APGiDa+Pf0N/XzQNynWWyzC2krv+fQq5YjGypRbnvciAtGbJQSXBoX58eV6sd5CWLKGMo1gHxsXNU6L9v9XlSWLUH4xbYvQt+oxfptgJbK5E+71OYC8DL0KU6xmlEfuPNQZ1Rf3pqqlEfmQjP24ubcgy3ZAHVTFBh7rT66pw+L5zAVPYBCyUG7rdXHS9hulRa4Y8w3BFRBxbChHsc7tuKk9kQmNGhQAJ7CdJx3V5kPsrxnuztOunimeBKoB5X3wgvk9f64n60Jp0qumnY4l9V6oZAgMBAAGjggHHMIIBwzASBgNVHRMBAf8ECDAGAQH/AgEAMBEGCWCGSAGG+EIBAQQEAwIBBjCBywYDVR0gBIHDMIHAMIG9BgkqgXaEBQEKAQEwga8wgYQGCCsGAQUFBwICMHgadlZhcm1lbm5lcG9saXRpaWtrYSBvbiBzYWF0YXZpbGxhIC0gQ2VydGlmaWthdCBwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBwb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczEwJgYIKwYBBQUHAgEWGmh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczEvMEIGCCsGAQUFBwEBBDYwNDAyBggrBgEFBQcwAoYmaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jYS92cmtyb290Yy5jcnQwDgYDVR0PAQH/BAQDAgHGMB8GA1UdIwQYMBaAFNvp4ZvS0SQL/KvjoGfqrpxLd/SwMDgGA1UdHwQxMC8wLaAroCmGJ2h0dHA6Ly9wcm94eS5maW5laWQuZmkvYXJsL3Zya3Jvb3RhLmNybDAdBgNVHQ4EFgQUiFpvHUJHgob91+kNslfPTVAoBBcwDQYJKoZIhvcNAQEFBQADggEBAEXit6ypQO+0RbVTK57SKT1jsqE8dUiwL8oevvdBiFpR4HxEZZy8e/OGAvF3Hc/Hjc8cOjlsYToqztg16cOFI4vHZ+yC8rWh4TpuWgvkS80h//jcweAayp6E/Z0z928vTNILBD34YJQvpU4u7jyhSaY3tzybKjlSAo5lahiI32a9MNZXGoNv+j+MKq1NJkpgpy6/VEa5Z4RdRx43/EZhs45WvxTfER+nUC1loQngFKOSjdWG3GhOAh13nM9jYASBtC7ONddvoByfzwUOQ+BOf08R2bvZA+2CDFI8PuYqxCFvBMCpQSCdVL6tEYxeWIQb+uIQsfAEfjC3AQuTNh/UiW8= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2021-07-07T07:07:55Z + + http://ocsp.fineid.fi/vrkcqc + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Citizen qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK Gov. CA for Citizen Qualified Certificates + + + + CN=VRK Gov. CA for Citizen Qualified Certificates, OU=Valtion kansalaisvarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + iFpvHUJHgob91+kNslfPTVAoBBc= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2016-06-30T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Citizen qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK Gov. CA for Citizen Qualified Certificates + + + + CN=VRK Gov. CA for Citizen Qualified Certificates, OU=Valtion kansalaisvarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + iFpvHUJHgob91+kNslfPTVAoBBc= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/undersupervision + 2003-03-31T10:00:00Z + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK Gov. CA for Citizen Qualified Certificates - G2 + + + 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 + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2023-12-19T22:00:33Z + + http://ocsp.fineid.fi/vrkcqc2 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Citizen qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK Gov. CA for Citizen Qualified Certificates - G2 + + + + CN=VRK Gov. CA for Citizen Qualified Certificates - G2, OU=Valtion kansalaisvarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + wa8dil8dmocNghD8nd31sB5w07U= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2016-06-30T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Citizen qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK Gov. CA for Citizen Qualified Certificates - G2 + + + + CN=VRK Gov. CA for Citizen Qualified Certificates - G2, OU=Valtion kansalaisvarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + wa8dil8dmocNghD8nd31sB5w07U= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/undersupervision + 2014-01-08T11:00:00Z + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Qualified Certificates + + + +MIIFejCCBGKgAwIBAgIDAYiaMA0GCSqGSIb3DQEBBQUAMIGjMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4gUm9vdCBDQTAeFw0wMzAxMTQwNzU3MDJaFw0xOTAxMTMwNzU2MTBaMIGPMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMR8wHQYDVQQLExZPcmdhbmlzYWF0aW92YXJtZW50ZWV0MSowKAYDVQQDEyFWUksgQ0EgZm9yIFF1YWxpZmllZCBDZXJ0aWZpY2F0ZXMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCxGO4peMUc0UklH4cTBXBs8I3/BpGUvNYMSvN9wkMe8zJxW7eLuOAuNrbQUdLE57hzOOjYY67LP2zGyWCU5codtdpT+M+qTgdohtGZwPw1FyNOp1aiDjjVLCBBKEzxfVWrglzmf4zPIF1jJBKspUuJtjWkdtqcNCeb9ZPV8J9yS6+V7TTUGv63VCx48AfkWegKRHrBJxtby07P4liRpoQgZ4uYy2sD3rHuQnv3ukbx3VxtMKHLAGwzQa/yBPGcFha5IeWnONTx+3YrJYTysKvtE7z302tQvpl+WFTsOXKhsM7/TEf+EerUqY7P36H/qUvyFsvvzotRP858s4r3eQlRAgMBAAGjggHHMIIBwzASBgNVHRMBAf8ECDAGAQH/AgEAMBEGCWCGSAGG+EIBAQQEAwIBBjCBywYDVR0gBIHDMIHAMIG9BgkqgXaEBQEKAQIwga8wgYQGCCsGAQUFBwICMHgadlZhcm1lbm5lcG9saXRpaWtrYSBvbiBzYWF0YXZpbGxhIC0gQ2VydGlmaWthdCBwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBwb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczIwJgYIKwYBBQUHAgEWGmh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczIvMEIGCCsGAQUFBwEBBDYwNDAyBggrBgEFBQcwAoYmaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jYS92cmtyb290Yy5jcnQwDgYDVR0PAQH/BAQDAgHGMB8GA1UdIwQYMBaAFNvp4ZvS0SQL/KvjoGfqrpxLd/SwMDgGA1UdHwQxMC8wLaAroCmGJ2h0dHA6Ly9wcm94eS5maW5laWQuZmkvYXJsL3Zya3Jvb3RhLmNybDAdBgNVHQ4EFgQUVBoCN4+OY9+P8DAjSqj8Z1fwU6gwDQYJKoZIhvcNAQEFBQADggEBAF9FRZ3uzOv7VtEy/AudyUgNXmqgt7a2hns6jjGUegvZThpHESJ3SAz1dtIXbmQ1XM0j8CKb5GRmgBMMbqXgWVEuvw6Jikh0If9TYMtnw0y5QDZig1rmCvwZnz/LR9IkcqU7MdaWFDPOQzDfnZX90cerh+bn9DuHhcZ3xtiy9OwXOVpp8w8rcoVY4+3A1Sn1QmNsEsuxZDoKZiwNZn87IKRj5h5okh3Tsu8XXtV+Lc4bQnY2mtDA0vMgZ9KJlM6NwrXOc4f9unALJkyX3Ygd2DfvrIKOJlKIm7/c91Xc9vBW8uGlFDOyzdhhcDYt30Gb1eBcLxxSdkcuIFcIq7cMyvE= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2021-07-07T07:08:45Z + + http://ocsp.fineid.fi/vrkqc + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Qualified Certificates + + + + CN=VRK CA for Qualified Certificates, OU=Organisaatiovarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + VBoCN4+OY9+P8DAjSqj8Z1fwU6g= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2016-06-30T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Qualified Certificates + + + + CN=VRK CA for Qualified Certificates, OU=Organisaatiovarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + VBoCN4+OY9+P8DAjSqj8Z1fwU6g= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/undersupervision + 2003-03-31T10:00:00Z + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Qualified Certificates - G2 + + + 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 + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2023-12-19T22:00:37Z + + http://ocsp.fineid.fi/vrkqc2 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Qualified Certificates - G2 + + + + CN=VRK CA for Qualified Certificates - G2, OU=Organisaatiovarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + VqlXr9YxfnHWLboO4+6KExTKKdc= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2016-06-30T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Qualified Certificates - G2 + + + + CN=VRK CA for Qualified Certificates - G2, OU=Organisaatiovarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + VqlXr9YxfnHWLboO4+6KExTKKdc= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/undersupervision + 2014-01-08T11:00:00Z + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Healthcare Professionals Qualified Certificates + + + +MIIFjDCCBHSgAwIBAgIDAaZVMA0GCSqGSIb3DQEBBQUAMIGjMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4gUm9vdCBDQTAeFw0xMDEwMjcxMTQxMjZaFw0yMzEyMTcxOTU5NTlaMIG0MQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSswKQYDVQQLEyJUZXJ2ZXlkZW5odW9sbG9uIGFtbWF0dGl2YXJtZW50ZWV0MUMwQQYDVQQDEzpWUksgQ0EgZm9yIEhlYWx0aGNhcmUgUHJvZmVzc2lvbmFscyBRdWFsaWZpZWQgQ2VydGlmaWNhdGVzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr+HbiIMhxbvT7n7lF4DpnO1ICRXEUleN6eo//szmbvONfNaJtjKlz6rYGMlH1m3DNVlCn5RVHkXb9pNCxXYoqBV00RO/Ry7nEy0dB/ZVlck80CUIHtK5sYC9RKe0YSa3xQKA5xhPFcy6wxmE6jeqs0r32S+qvbUU5VejHTfU+cTghwLiE0XLwBTjK5cX8S8gGHsZvgJUvID/g94l6AaOC3xOVSezGWW2VJicMUl1n/dNpjQsyten03TRjGWI5Tg27wNZvGbQZjwuXWkb+NzAG7lcq4WzCb9Sp/dG+G5AAeU/JWt7fmabQxxFSjv7sg0koJCxWkRdhXkNRL332qRQYwIDAQABo4IBtDCCAbAwEgYDVR0TAQH/BAgwBgEB/wIBADCBywYDVR0gBIHDMIHAMIG9BgkqgXaEBQEKAQcwga8wgYQGCCsGAQUFBwICMHgadlZhcm1lbm5lcG9saXRpaWtrYSBvbiBzYWF0YXZpbGxhIC0gQ2VydGlmaWthdCBwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBwb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczYwJgYIKwYBBQUHAgEWGmh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczYvMEIGCCsGAQUFBwEBBDYwNDAyBggrBgEFBQcwAoYmaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jYS92cmtyb290Yy5jcnQwDgYDVR0PAQH/BAQDAgHGMB8GA1UdIwQYMBaAFNvp4ZvS0SQL/KvjoGfqrpxLd/SwMDgGA1UdHwQxMC8wLaAroCmGJ2h0dHA6Ly9wcm94eS5maW5laWQuZmkvYXJsL3Zya3Jvb3RhLmNybDAdBgNVHQ4EFgQUzRt/1lZfBvUKKTJe6i1snCZYABIwDQYJKoZIhvcNAQEFBQADggEBAGGkQW99duGBicXk4r2Q9tspbIHDbvum7+ARNjxNuTtMlXOEQzXhA98Ai33fY6WOq1MMV9wTuNfjacvTB5H0hWjmMSWEqOCS/Xvt1Mn/+hWvRu1el6eRf9euAfMJmFxsS3fwcdrY4g/O4yuM2dc/mb8Ziyz33mm7p0qGYcMZxqADcUnczezPf2CV/qZHaxGS7if0sEoNC04KnPg/4WbcqzbwrPaGTd/m+TX4DhY4SyehMCbI3yxwuOK2VHkGKDPRDo2zH5yHL+0MxCu9N7wMuq3n5WxbVL/B+Bv+6ccLYL0H6c+3SIkpESiNU9Gx2TJf/PcO37Nbj/RN0jY4UZPRed4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2023-12-19T22:00:37Z + + http://ocsp.fineid.fi/vrkhcp + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Healthcare Professionals Qualified Certificates + + + + CN=VRK CA for Healthcare Professionals Qualified Certificates, OU=Terveydenhuollon ammattivarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + zRt/1lZfBvUKKTJe6i1snCZYABI= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2016-06-30T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Healthcare Professionals Qualified Certificates + + + + CN=VRK CA for Healthcare Professionals Qualified Certificates, OU=Terveydenhuollon ammattivarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + zRt/1lZfBvUKKTJe6i1snCZYABI= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/undersupervision + 2010-12-01T11:00:00Z + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK Gov. CA for Citizen Certificates - G3 + + + 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 + + +CN=VRK Gov. CA for Citizen Certificates - G3, OU=Valtion kansalaisvarmenteet, O=Vaestorekisterikeskus CA, C=FI + + +gylrX//D7PQ/SNWapZ7Jxtg02cI= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-02-18T22:00:00Z + + http://ocsp.fineid.fi/vrkcqc3 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Citizen qualified certificates for generating electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Organisational Certificates - G3 + + + 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 + + +CN=VRK CA for Organisational Certificates - G3, OU=Organisaatiovarmenteet, O=Vaestorekisterikeskus CA, C=FI + + +RIjvhAXfAvaTfLSemZ26WY8Gve8= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-02-18T22:00:00Z + + http://ocsp.fineid.fi/vrkqc3 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + + + + true + + Qualified certificates for electronic signatures. Certificate private keys are stored on a smart card. + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Service Providers - G3 + + + +MIIGUTCCBTmgAwIBAgIDAaqXMA0GCSqGSIb3DQEBCwUAMIGjMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4gUm9vdCBDQTAeFw0xNTEyMDcwOTEyMzRaFw0yMzEyMTgxMzUxMDhaMHgxCzAJBgNVBAYTAkZJMSEwHwYDVQQKExhWYWVzdG9yZWtpc3RlcmlrZXNrdXMgQ0ExGjAYBgNVBAsTEVBhbHZlbHV2YXJtZW50ZWV0MSowKAYDVQQDEyFWUksgQ0EgZm9yIFNlcnZpY2UgUHJvdmlkZXJzIC0gRzMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC0r66RxSfZpdehxUGXHNw18KQBjYDnlYJI756MCTwUKVCDtqTJHCYZp/34VwU/ZmE8H7OocM4AogvC8027M1pE0mVddU92HIu+DG4l3040NTmeWfVV/GXcL2AOOLRZowcTHzycr/+iXHIURJ3CQTTbCG0r61JGSV5bGXQGXQ2fhl/9ovd3uGA4f2rw8EOBgdbrFtTwskn9E57+MCf7GPFo9u46452IUg2nK21SZTfixd70eXbmSKHOZ7AGWk04VJntfRsqzA04qqBhFFwQ49vVibvCVkU9tuVFhLJyEozDWv/UxfIgOVpQp7SplbkfbmP4AtOlNT4Y6cKpSb4zsetL7GlsKxSqdG19k1yM9uDd0ig/+baavm4vDo8irkkTV+T52FsBKlHFKzvgvYVWvvhRbOjVOWw/hUM6/SanyyFuU8GGNKYWz3/LcXmUOyktANPeGcWdxG9eCDNW3rdKMW2ef+lAY/8yCwiXRTIYcIAvUoKvI7u04W+Lp2XbPOi7ut3MmPS9Aprl0x/ybqNxQu0V2FSNpEGyH+jkitJgaU8qzCLgbm6X+5OR76aFvWYZNNVzcbC+E/LBUd3neVtEzADEYcYEV2ojfPnhmCuH7ySeaWnKMI/lsEnFE/t39jAVbfn4OXgB6GdHFGNLRy5dPDxBQaV5cBMElHJ3dn/UXwSoqQIDAQABo4IBtjCCAbIwHwYDVR0jBBgwFoAU2+nhm9LRJAv8q+OgZ+qunEt39LAwHQYDVR0OBBYEFGUE6C2S58sqq1cVqGUqqvq3FnT2MA4GA1UdDwEB/wQEAwIBBjCBzQYDVR0gBIHFMIHCMIG/BgkqgXaEBQEKHwMwgbEwgYUGCCsGAQUFBwICMHkad1Zhcm1lbm5lcG9saXRpaWtrYSBvbiBzYWF0YXZpbGxhIC0gQ2VydGlmaWthdCBwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBwb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczMzMCcGCCsGAQUFBwIBFhtodHRwOi8vd3d3LmZpbmVpZC5maS9jcHMzMy8wEgYDVR0TAQH/BAgwBgEB/wIBADA4BgNVHR8EMTAvMC2gK6AphidodHRwOi8vcHJveHkuZmluZWlkLmZpL2FybC92cmtyb290YS5jcmwwQgYIKwYBBQUHAQEENjA0MDIGCCsGAQUFBzAChiZodHRwOi8vcHJveHkuZmluZWlkLmZpL2NhL3Zya3Jvb3RjLmNydDANBgkqhkiG9w0BAQsFAAOCAQEATSk29L3m8/OA+/0Z/2dDX+smXVsyqO3syQD7WP686VpsPZdHdiiCTLiL4X93KOX4+XK7sTZ8SA/w49MrGAR6AArgwndu4Xuer3uqLE1fMrcaaMOFJSn4V7OyEfkx7kh5WrcHOwIaTr0Nj0zNJWnXXvJboDfFM6rLNG4Yc5eb4NFVOPgUfvp3X5Bh2i5Ehxvtt5OKXNQDjCAUGGbGNjv4gJDcdPLelTWm4RkC0iHANouEdZ2EKis3SvRxAjbqXMpvQ2raAkeve8/jUrwyl+UEUnZYIDIiMWjBqRX+Aqeh0CyW4ZHKsC04kXEqhYPjSskJEIRHbvU3e2vt81IJGBLALQ== + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2023-12-19T22:00:51Z + + http://ocsp.fineid.fi/vrksp3 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + + + urn:oid:1.2.246.517.1.10.34 + + + VRK CA for Service Providers QWAC + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Service Providers - G3 + + + + CN=VRK CA for Service Providers - G3, OU=Palveluvarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + ZQToLZLnyyqrVxWoZSqq+rcWdPY= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + + + urn:oid:1.2.246.517.1.10.34 + + + VRK CA for Service Providers QWAC + + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Service Providers - G4 + + + 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 + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + http://ocsp.fineid.fi/vrksp4 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + + + urn:oid:1.2.246.517.1.10.205 + + + VRK CA for Service Providers – G4 + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Social Welfare and Health Care Service Providers + + + +MIIFeTCCBGGgAwIBAgIDAaZUMA0GCSqGSIb3DQEBBQUAMIGjMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4gUm9vdCBDQTAeFw0xMDEwMjcxMTIwMjFaFw0yMzEyMTcxOTU5NTlaMIGhMQswCQYDVQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vza3VzIENBMSswKQYDVQQLEyJUZXJ2ZXlkZW5odW9sbG9uIHBhbHZlbHV2YXJtZW50ZWV0MTAwLgYDVQQDEydWUksgQ0EgZm9yIEhlYWx0aGNhcmUgU2VydmljZSBQcm92aWRlcnMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCwixktTUBdjaAedTmyjoPHzkuN53eUkFKIDoUMUOavZ7HYfj+/GjR2mmNGwWk/F9E4qqpfCbe/a62tGSMdJyOYO87x/l73gzJQmrSglEODfUnFos9pu3hoXFZY2bFnxCwm1HIbck9rvlhJjKiWpKc45V/w3GlfKuv+LD3hd0MTj4/J3o+wvtgzUcUeqHy8sX51h2JM5HoVaNV4F4DGSXBH8JEoPsbk9FkB2RsiXt2r+kDHiWILGfmYpQY5RiMV3sG4/gflSTtk2LorMFgHHgzX5rQB8DOl4jhAMW/o5OlL26HVRh8X9DhMHUwIMBE7mvh/R5gHQ1JRvAFyCTZFSHUBAgMBAAGjggG0MIIBsDASBgNVHRMBAf8ECDAGAQH/AgEAMIHLBgNVHSAEgcMwgcAwgb0GCSqBdoQFAQoBCTCBrzCBhAYIKwYBBQUHAgIweBp2VmFybWVubmVwb2xpdGlpa2thIG9uIHNhYXRhdmlsbGEgLSBDZXJ0aWZpa2F0IHBvbGljeSBmaW5ucyAtIENlcnRpZmljYXRlIHBvbGljeSBpcyBhdmFpbGFibGUgaHR0cDovL3d3dy5maW5laWQuZmkvY3BzODAmBggrBgEFBQcCARYaaHR0cDovL3d3dy5maW5laWQuZmkvY3BzOC8wQgYIKwYBBQUHAQEENjA0MDIGCCsGAQUFBzAChiZodHRwOi8vcHJveHkuZmluZWlkLmZpL2NhL3Zya3Jvb3RjLmNydDAOBgNVHQ8BAf8EBAMCAcYwHwYDVR0jBBgwFoAU2+nhm9LRJAv8q+OgZ+qunEt39LAwOAYDVR0fBDEwLzAtoCugKYYnaHR0cDovL3Byb3h5LmZpbmVpZC5maS9hcmwvdnJrcm9vdGEuY3JsMB0GA1UdDgQWBBQU8WvfSqXQIu2rs5GnzYtf2vu6XjANBgkqhkiG9w0BAQUFAAOCAQEAehZR4e0YLiAaKJjzOlveOADXeuHRPGxSt0OcJts9iOsBOyTKiF5p4wLpAY1otqV6tlnHUz9AaIO8ZUmovyBsOejV7dywyhcXoFCwsfOHvq7hdHzSxlh6QJyE/VoYtTepqT+pWmoYR4WomdxFBv+LUQgnQ5602MNe21AV7XlMIFPmIymGaCiwvDzLcnKYtWjhwBx015nnSkLv+Pw6HGsUAZJyMhLtNMbwlFuwrIN8EpyzrHY8Egqn3Wgdq878OdzrvOqm7s06ed6kmQURMMbwlwCYtOmDajVpeudK0T4c1ZFRE8UKnuhPvUBowjZmoY040x/Q9Pd1b33f2jjl49On5g== + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/withdrawn + 2023-12-19T22:00:33Z + + http://ocsp.fineid.fi/vrkshsp + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + VRK CA for Social Welfare and Health Care Service Providers + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Social Welfare and Health Care Service Providers + + + + CN=VRK CA for Healthcare Service Providers, OU=Terveydenhuollon palveluvarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + FPFr30ql0CLtq7ORp82LX9r7ul4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + VRK CA for Social Welfare and Health Care Service Providers + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Social Welfare and Health Care Service Providers + + + + CN=VRK CA for Healthcare Service Providers, OU=Terveydenhuollon palveluvarmenteet, O=Vaestorekisterikeskus CA, ST=Finland, C=FI + + + FPFr30ql0CLtq7ORp82LX9r7ul4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + VRK CA for Social Welfare and Health Care Service Providers + + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + VRK CA for Social Welfare and Healthcare Service Providers - G2 + + + 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 + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + http://ocsp.fineid.fi/vrkshsp2/ + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + VRK CA for Social Welfare and Healthcare Service Providers - G2 + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + +VRK CA for Social Welfare and Healthcare Service Providers - G2 + + + + CN=VRK CA for Social Welfare and Healthcare Service Providers - G2, OU=Sosiaali- ja terveydenhuollon palveluvarmenteet, O=Vaestorekisterikeskus CA, C=FI + + + OfrFdOd7rUbJK+Nvkx7PHOt/Spg= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2019-11-11T22:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + + + + true + true + + VRK CA for Social Welfare and Healthcare Service Providers - G2 + + + + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Citizen Certificates - G4R + + + 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 + + +CN=DVV Citizen Certificates - G4R, OU=Valtion kansalaisvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +CNFOufITWf+79Rwu2CPc1sH+P8Q= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T09:36:02Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Organisational Certificates - G4R + + + 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 + + +CN=DVV Organisational Certificates - G4R, OU=Organisaatiovarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +bX6Lmv8bet1onbtSHPSu5eX0YWM= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:05:35Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Citizen Certificates - G4E + + + +MIIETDCCA9KgAwIBAgIPAXmjXvtQumEdfpYyCyqjMAoGCCqGSM49BAMDMIGgMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSkwJwYDVQQLDCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECwwQVmFybWVubmVwYWx2ZWx1dDEiMCAGA1UEAwwZRFZWIEdvdi4gUm9vdCBDQSAtIEczIEVDQzAeFw0yMTA1MjUxMTIxMjNaFw00MTA1MjAxMTUxMjNaMIGFMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSQwIgYDVQQLDBtWYWx0aW9uIGthbnNhbGFpc3Zhcm1lbnRlZXQxJzAlBgNVBAMMHkRWViBDaXRpemVuIENlcnRpZmljYXRlcyAtIEc0RTB2MBAGByqGSM49AgEGBSuBBAAiA2IABIEokH+BOa94mIFN81qYpnaXdoqsbos6LAsXx8etuneaLubsDU8FblCU98Mlh3GWeI1rygN01Tl5QfMwqWXgKM+1hBVMph9HXs6EURSyiw5M6x1+0LW+5VNqri4fdb/rhKOCAekwggHlMB8GA1UdIwQYMBaAFLl2gMOD+M8i2oXrzhROVaxeWgqQMB0GA1UdDgQWBBTfnLy8guihqFMml/l0o+zqHcmXzjAOBgNVHQ8BAf8EBAMCAQYwgc4GA1UdIASBxjCBwzCBwAYKKoF2hAUBCoJfATCBsTCBhQYIKwYBBQUHAgIweRp3VmFybWVubmVwb2xpdGlpa2thIG9uIHNhYXRhdmlsbGEgLSBDZXJ0aWZpa2F0cG9saWN5IGZpbm5zIC0gQ2VydGlmaWNhdGUgUG9saWN5IGlzIGF2YWlsYWJsZSBodHRwOi8vd3d3LmZpbmVpZC5maS9jcHM2MS8wJwYIKwYBBQUHAgEWG2h0dHA6Ly93d3cuZmluZWlkLmZpL2NwczYxLzASBgNVHRMBAf8ECDAGAQH/AgEAMDoGA1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly9wcm94eS5maW5laWQuZmkvY3JsL2R2dnJvb3QzZWMuY3JsMHIGCCsGAQUFBwEBBGYwZDAsBggrBgEFBQcwAYYgaHR0cDovL29jc3AuZmluZWlkLmZpL2R2dnJvb3QzZWMwNAYIKwYBBQUHMAKGKGh0dHA6Ly9wcm94eS5maW5laWQuZmkvY2EvZHZ2cm9vdDNlYy5jcnQwCgYIKoZIzj0EAwMDaAAwZQIwUixZ5bk5z7His6PZMYmsY0pfVR2MYEIM5tG4O87DQ5ixrsEMXcNYfyvTESYMFX6JAjEA72zRzpJJGenfZCCCFFE4VZHnsa8oEhbsK9R6wlUa5SSSy6099DeLuqKgXWTm8uP6 + + +CN=DVV Citizen Certificates - G4E, OU=Valtion kansalaisvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +35y8vILooahTJpf5dKPs6h3Jl84= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:07:31Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Organisational Certificates - G4E + + + +MIIETTCCA9SgAwIBAgIPAXmjZw+zzMLoZzmKAQOuMAoGCCqGSM49BAMDMIGgMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSkwJwYDVQQLDCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECwwQVmFybWVubmVwYWx2ZWx1dDEiMCAGA1UEAwwZRFZWIEdvdi4gUm9vdCBDQSAtIEczIEVDQzAeFw0yMTA1MjUxMTMwMzhaFw00MTA1MjAxMjAwMzhaMIGHMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMR8wHQYDVQQLDBZPcmdhbmlzYWF0aW92YXJtZW50ZWV0MS4wLAYDVQQDDCVEVlYgT3JnYW5pc2F0aW9uYWwgQ2VydGlmaWNhdGVzIC0gRzRFMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETWLsnhdkXbp0420XMzwgZ1spLm+INk936ci2Slx21X074XybK2kbKkysPeAAFe8VR/azZJtJVnSRkRZRA0W0D9B7zyP7vO9B9r8RvBQNUWWtncMaQB5RKZwjZJ9Bo4ozo4IB6TCCAeUwHwYDVR0jBBgwFoAUuXaAw4P4zyLahevOFE5VrF5aCpAwHQYDVR0OBBYEFGfxNV/xhFNfYVVkmjsgfWK0YnaYMA4GA1UdDwEB/wQEAwIBBjCBzgYDVR0gBIHGMIHDMIHABgoqgXaEBQEKgl8CMIGxMIGFBggrBgEFBQcCAjB5GndWYXJtZW5uZXBvbGl0aWlra2Egb24gc2FhdGF2aWxsYSAtIENlcnRpZmlrYXRwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBQb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczYyLzAnBggrBgEFBQcCARYbaHR0cDovL3d3dy5maW5laWQuZmkvY3BzNjIvMBIGA1UdEwEB/wQIMAYBAf8CAQAwOgYDVR0fBDMwMTAvoC2gK4YpaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jcmwvZHZ2cm9vdDNlYy5jcmwwcgYIKwYBBQUHAQEEZjBkMCwGCCsGAQUFBzABhiBodHRwOi8vb2NzcC5maW5laWQuZmkvZHZ2cm9vdDNlYzA0BggrBgEFBQcwAoYoaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jYS9kdnZyb290M2VjLmNydDAKBggqhkjOPQQDAwNnADBkAjByexqK4N+BGaQS3l8gp8gC1sbpzIlak6YS0bl+t8ZlSYy7Daa8WkjKCwiZbCjePo8CMA0I9TyxoNkDHCq5VPdXTKr/jlgyppTwxHNgbk/7ARKMK/2ZrRRI20mZ7grdVhnXMg== + + +CN=DVV Organisational Certificates - G4E, OU=Organisaatiovarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +Z/E1X/GEU19hVWSaOyB9YrRidpg= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:08:49Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Social Welfare and Healthcare Service Certificates - G3R + + + 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 + + +CN=DVV Social Welfare and Healthcare Service Certificates - G3R, OU=Sosiaali- ja terveydenhuollon palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +fqc7m1+FjkbI48WHOM8NLw7yeQA= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:10:07Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Service Certificates - G5R + + + +MIIHrzCCBZegAwIBAgIPAXmjmcRZYAs1O6eZhxkvMA0GCSqGSIb3DQEBDQUAMIGgMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSkwJwYDVQQLDCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECwwQVmFybWVubmVwYWx2ZWx1dDEiMCAGA1UEAwwZRFZWIEdvdi4gUm9vdCBDQSAtIEczIFJTQTAeFw0yMTA1MjUxMTM5MzlaFw00MTA1MjAxMjA5MzlaMHsxCzAJBgNVBAYTAkZJMScwJQYDVQQKDB5EaWdpLSBqYSB2YWVzdG90aWV0b3ZpcmFzdG8gQ0ExGjAYBgNVBAsMEVBhbHZlbHV2YXJtZW50ZWV0MScwJQYDVQQDDB5EVlYgU2VydmljZSBDZXJ0aWZpY2F0ZXMgLSBHNVIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC7HE7Lkfnp6UF9UYm+owT9+pt7v7J5RFg5E40juDGXtSWhQ17VSXBwnnyoJOdzCSUouW/Cteu/M+FpQbaPRpl8iBcfSjKZ5ignJHAJZF6Ph6TSBUgg6dArGhWfH4dUQUvHvDSYUYzrp9SK+2YqgZAegl+f3Z/6zv7p9RoJRNkwT9L2boAE1FD2s+YJbO0dC2Ex8K/sB70i75CQ5BsmnoF7YeJs4UyW7aUjR9V+Y2+W6ifzEy7oplGjH9ZnGVfS5NzQCAIJ1V+ZRT+PSlbbhWdvdwqfxmuriHhjOUzTZZBqLT5HGb2Nykvn3kvNWFTfNbZJ6t0OGBVL1bDm9R5gQJqGOO4KOppx/WZSyMkel9QlFmHAjZtURgvB6VNWp7rzXN2SF4wpbVpEKiGxBommnDx9lvUA1untZdqHWs2lIxyt/32bql7d4pfDgX7LMgGEYWnHCDffLVLcFgNzg1pBExa+xKnYd4XQU6iHYr35jefvy6cO6QCbrOya+vc2v5chwf6WtEJwors+N3dPE6ubOXqOGLYv4VdHAetjDkl8pddgvmiADU0Bty4xNHsMhLIwcVry4v3rWHp37c+YzOmQbjiZKyOiq2jeJAo2g8pduDF3I9T0Bh2BuGj0u7c2ud+bK9VpNY5HLLhuALwPTmhUWOTBvtcxyvWmZsEaXN2MvN+mnQIDAQABo4ICCDCCAgQwHwYDVR0jBBgwFoAUWwHgz17QxIC1UIqBOIeDkr8VDIwwHQYDVR0OBBYEFOSQsKgXg6OemtX9PclZax8gsuK+MA4GA1UdDwEB/wQEAwIBBjCBzgYDVR0gBIHGMIHDMIHABgoqgXaEBQEKgi0EMIGxMIGFBggrBgEFBQcCAjB5GndWYXJtZW5uZXBvbGl0aWlra2Egb24gc2FhdGF2aWxsYSAtIENlcnRpZmlrYXRwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBQb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczU0LzAnBggrBgEFBQcCARYbaHR0cDovL3d3dy5maW5laWQuZmkvY3BzNTQvMBIGA1UdEwEB/wQIMAYBAf8CAQAwOgYDVR0fBDMwMTAvoC2gK4YpaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jcmwvZHZ2cm9vdDNyYy5jcmwwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMHIGCCsGAQUFBwEBBGYwZDAsBggrBgEFBQcwAYYgaHR0cDovL29jc3AuZmluZWlkLmZpL2R2dnJvb3QzcmMwNAYIKwYBBQUHMAKGKGh0dHA6Ly9wcm94eS5maW5laWQuZmkvY2EvZHZ2cm9vdDNyYy5jcnQwDQYJKoZIhvcNAQENBQADggIBALzu0Hnivk3G5wrR9Wh93MuUnKDtKc9+QYd/IgPVODBzhi7Ol49jMy9UahjhG46S/mKEjQpVaiWRby28y6YRCBC9kcyLnNfqw4UY1at3FAlwQZIexXBS9oD5kQHNWNL/NSQ+K/Qa+08fE02k6UPeOglOZIBjUoFgkDuHXaubWeRK1hWH3CjBr0kDcdxS4Ww658Eiprz0kHgOtHRviIGAPV5GP9Y5dKK4cW+4P01x57GjqbhWs66GTdPRF7SYE4u2IThjrdqZttC6fA1DtgIZq+xeWZoI/5pSS2Zm1JQhFtzLXLYIzpvcVxSnSagQS9E0/pQ44fMb7revsPsjPAf5x9bDFWdfAHZ/fc1LCeYZrmZdVbNNEptv1tqIPPCgwegCNiaywqZqQ94T6hBVE4hfuUukMGgDfNJyhB9V1aOsRArnFPqk9CoOIq8d0AOjNf2L05UV8Vbcx8rR8YlbsAJVLaAiXgGDAOJXd8nd8lnydsz0ADPYOOv4TyLyEzw502+70ZR4YqS07ijTP+EnRsbBLYzvTtpvxv6rOegDEJFPDiUzjcK8B0lHpsETTS2BYclMkWiGx6GVzErcrYurw/s/AFgpTVD9zdESdtgL1qxUJ9puuUmCGo2mBD3hcvI+zaqjfmezJTg7fz9dzICqzs+I6OsybDdBUvfjNOA+kHo6sqWd + + +CN=DVV Service Certificates - G5R, OU=Palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +5JCwqBeDo56a1f09yVlrHyCy4r4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:12:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Social Welfare and Healthcare Service Certificates - G3E + + + +MIIEnTCCBCOgAwIBAgIPAXmjqNnORa3Ub51yu8mbMAoGCCqGSM49BAMDMIGgMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSkwJwYDVQQLDCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECwwQVmFybWVubmVwYWx2ZWx1dDEiMCAGA1UEAwwZRFZWIEdvdi4gUm9vdCBDQSAtIEczIEVDQzAeFw0yMTA1MjUxMTQ0MjRaFw00MTA1MjAxMjE0MjRaMIG3MQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMTgwNgYDVQQLDC9Tb3NpYWFsaS0gamEgdGVydmV5ZGVuaHVvbGxvbiBwYWx2ZWx1dmFybWVudGVldDFFMEMGA1UEAww8RFZWIFNvY2lhbCBXZWxmYXJlIGFuZCBIZWFsdGhjYXJlIFNlcnZpY2UgQ2VydGlmaWNhdGVzIC0gRzNFMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEb4FbgznGxGR8LsYqdUf+UdBVJ+x8w1pc2LElQKdGH3xMObn7HUbXl7pIhs3WyQZ+sJp7kGty+bRhO/ly7aL96qMFZ4NcObOEj59Sb5W1ac+vfhENC/mVg3M93Z2fZ/vto4ICCDCCAgQwHwYDVR0jBBgwFoAUuXaAw4P4zyLahevOFE5VrF5aCpAwHQYDVR0OBBYEFGaoLyb/vJit/NEhcoouf4lE+9xkMA4GA1UdDwEB/wQEAwIBBjCBzgYDVR0gBIHGMIHDMIHABgoqgXaEBQEKgl8HMIGxMIGFBggrBgEFBQcCAjB5GndWYXJtZW5uZXBvbGl0aWlra2Egb24gc2FhdGF2aWxsYSAtIENlcnRpZmlrYXRwb2xpY3kgZmlubnMgLSBDZXJ0aWZpY2F0ZSBQb2xpY3kgaXMgYXZhaWxhYmxlIGh0dHA6Ly93d3cuZmluZWlkLmZpL2NwczY3LzAnBggrBgEFBQcCARYbaHR0cDovL3d3dy5maW5laWQuZmkvY3BzNjcvMBIGA1UdEwEB/wQIMAYBAf8CAQAwOgYDVR0fBDMwMTAvoC2gK4YpaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jcmwvZHZ2cm9vdDNlYy5jcmwwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMHIGCCsGAQUFBwEBBGYwZDAsBggrBgEFBQcwAYYgaHR0cDovL29jc3AuZmluZWlkLmZpL2R2dnJvb3QzZWMwNAYIKwYBBQUHMAKGKGh0dHA6Ly9wcm94eS5maW5laWQuZmkvY2EvZHZ2cm9vdDNlYy5jcnQwCgYIKoZIzj0EAwMDaAAwZQIxANja/iz84laHByfvhUVeAXR5+4K2I9IdpTKWj/I8JEBGEsW3Qc/RH1QTw4wbIINekwIwDlk5FvWPaXVy2sm0FSkg8iAZFAXkXB+Rt06t5kOMrQGKoOhyXzvW2UQXT+axKToG + + +CN=DVV Social Welfare and Healthcare Service Certificates - G3E, OU=Sosiaali- ja terveydenhuollon palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +ZqgvJv+8mK380SFyii5/iUT73GQ= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:13:06Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/CA/QC + + DVV Service Certificates - G5E + + + +MIIEYTCCA+agAwIBAgIPAXmjnN0Ulr9oOyBEZQ5WMAoGCCqGSM49BAMDMIGgMQswCQYDVQQGEwJGSTEnMCUGA1UECgweRGlnaS0gamEgdmFlc3RvdGlldG92aXJhc3RvIENBMSkwJwYDVQQLDCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNlczEZMBcGA1UECwwQVmFybWVubmVwYWx2ZWx1dDEiMCAGA1UEAwwZRFZWIEdvdi4gUm9vdCBDQSAtIEczIEVDQzAeFw0yMTA1MjUxMTQwMjdaFw00MTA1MjAxMjEwMjdaMHsxCzAJBgNVBAYTAkZJMScwJQYDVQQKDB5EaWdpLSBqYSB2YWVzdG90aWV0b3ZpcmFzdG8gQ0ExGjAYBgNVBAsMEVBhbHZlbHV2YXJtZW50ZWV0MScwJQYDVQQDDB5EVlYgU2VydmljZSBDZXJ0aWZpY2F0ZXMgLSBHNUUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQ7ckyxoW3O9bAuV0fvRNzsy0T0oG6Ii/yYuSyU/3q5FnUBlJ43pPQX7D+hZaABNqKJSgyAFRjoUmblw9pfmwmWEqajBdDVTo8B4eUIFfbYpf7fbVOrHzOsFOCPD9j0quOjggIIMIICBDAfBgNVHSMEGDAWgBS5doDDg/jPItqF684UTlWsXloKkDAdBgNVHQ4EFgQUkMjwVQSeit97yWmt827jj0pQhV8wDgYDVR0PAQH/BAQDAgEGMIHOBgNVHSAEgcYwgcMwgcAGCiqBdoQFAQqCXwQwgbEwgYUGCCsGAQUFBwICMHkad1Zhcm1lbm5lcG9saXRpaWtrYSBvbiBzYWF0YXZpbGxhIC0gQ2VydGlmaWthdHBvbGljeSBmaW5ucyAtIENlcnRpZmljYXRlIFBvbGljeSBpcyBhdmFpbGFibGUgaHR0cDovL3d3dy5maW5laWQuZmkvY3BzNjQvMCcGCCsGAQUFBwIBFhtodHRwOi8vd3d3LmZpbmVpZC5maS9jcHM2NC8wEgYDVR0TAQH/BAgwBgEB/wIBADA6BgNVHR8EMzAxMC+gLaArhilodHRwOi8vcHJveHkuZmluZWlkLmZpL2NybC9kdnZyb290M2VjLmNybDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwcgYIKwYBBQUHAQEEZjBkMCwGCCsGAQUFBzABhiBodHRwOi8vb2NzcC5maW5laWQuZmkvZHZ2cm9vdDNlYzA0BggrBgEFBQcwAoYoaHR0cDovL3Byb3h5LmZpbmVpZC5maS9jYS9kdnZyb290M2VjLmNydDAKBggqhkjOPQQDAwNpADBmAjEA8jM3tw0PFhy9cGQEklcElWPZ3mHGWIILrBpqzWsYjqub+S/XCZLoMqGvHc3hsT/qAjEA12KaO2fAOo0yH4iSa7YuLI7ZA38IfVwfokGBwwt6VPTjYGTQTjv+DgabbR92VRUU + + +CN=DVV Service Certificates - G5E, OU=Palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +kMjwVQSeit97yWmt827jj0pQhV8= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2021-11-15T10:14:06Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForWebSiteAuthentication + + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/QESValidation/Q + + DVV Qualified validation service + + + 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 + + +CN=DVV Service Certificates - G5R, OU=Palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + +5JCwqBeDo56a1f09yVlrHyCy4r4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2026-08-21T06:05:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSeals + + + + + + + http://uri.etsi.org/TrstSvc/Svctype/QESValidation/Q + +DVV Qualified validation service + + + + CN=DVV Service Certificates - G5R, OU=Palveluvarmenteet, O=Digi- ja vaestotietovirasto CA, C=FI + + + 5JCwqBeDo56a1f09yVlrHyCy4r4= + + + http://uri.etsi.org/TrstSvc/TrustedList/Svcstatus/granted + 2026-08-16T21:00:00Z + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSignatures + + + + + http://uri.etsi.org/TrstSvc/TrustedList/SvcInfoExt/ForeSeals + + + + + + + + + +U4Om8VYj/423a3S6exjTmuVk0WY1rRaNUk2tZK7n9RPQnBcu4p30b7dv2n6t5sen0n19ZqqTu8RjL7Eo9ErR8w==Ba/zitKgIxrvbfXjlh5RIGVHsojUR2ZFc1q7hZrjEcUXgUMrx75DOnEhZu0IsBPvBzmxR2fd1bsbPLjILMZ4gA==Qq4+hf7nOrQTUWJd3kbbYHOEYMBVF6ftc05ufhg5oFE+I02ipe7KS+YQe4rHFJ+OX60xaTsp5DUYk2RJh13esZfyX2byCG/9flDU0uqeXevDEB8Yg7UeHAny4iRZi3iTOcvBd37wj5B4Af3lbcX8iEuQbMsNxIV1iT+KD8egHyd/pxMh9XplXT5OOOjyc46iG4htMV7cx0NfNeQnUTH9P4CE57uK2kwdrUJFSlZOfQP6dMJ6Sr/2vylIUTNZDRvwonyBJgB1uRwUjq6aPe/UMm59eu01jGuhSR9E7bdg9HnARO5g/or9BZyQdPk4sYn8pumUuZMvEvVX+20ZeBppDrB+eKYv00dsOVFqKMSohN8n1J1ZEu6kW0jryxznxUOafjVM3wmbFxkLcQipQnuN4k2lmO2o4ZkY3dFeAEtz5N9sM7tEOLQfd7Hc0jABIVxekm/xb+oPm41eFL/72x1y7qK2EgAFu99IFkTxP08/RAFlmRt2DI2sj8LubgrVx75BVfmFhQfxXZ9k/Q5komQvYCDz5GIk24q2vPXIxL8jFM5FoRkAMti7FTiD5E6LZBMr88eTL3F3jHngt2yUknk8BpL9TPbpWhndCx37cCAzLBe3C18k2O6G5DjmLTxvycAw1Bnz0TrMM0N9PLJso/4SEIyJWhcnttLJukCQBnfgK/w=MIIFhTCCA22gAwIBAgIFFKu+n4swDQYJKoZIhvcNAQENBQAwUjELMAkGA1UEBhMCRkkxJzAlBgNVBAoMHkxpaWtlbm5lLSBqYSB2aWVzdGludMOkdmlyYXN0bzEaMBgGA1UEAwwRU2NoZW1lT3BlcmF0b3IgSUkwHhcNMjUwNDE2MDAwMDAwWhcNMjgxMjE2MDAwMDAwWjBSMQswCQYDVQQGEwJGSTEnMCUGA1UECgweTGlpa2VubmUtIGphIHZpZXN0aW50w6R2aXJhc3RvMRowGAYDVQQDDBFTY2hlbWVPcGVyYXRvciBJSTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL11KF1pneMF86KKSWA3KYBflo/pMweA/AqUxx6fStMyegS07zyXtVnKmx9oFtiK0PtL7yJde8z26uYBk+R2udSC5NUWNv3qYRpBPXiYPfU+iYj+UomEt6MWEriw4ikaLlSgg7rO5RXg38fjdVg9R+Vv2t8m2//VSDbvqyC3eXWt+kyx9LHF1lSL9R3B2PDdMtO/LPufKyvdw9qKym+7/jzGfma/JWwO23Rhvu2+C3z+XPwt1CKpSrYy6VZofhfoCSvueI+pTXJXwi1J6bPzMkuNUsRC+s+HNvEk23GdxomrSnm//9y4exW4HjxiSoZGtSpBivo/stWeX1g425gjfLNAcq/WfUyMp2Vx40Zh2yvO/HgNuqCj6aWh2rsHAj2Gl3seO5TcCcnwYpnwB3BHArv5UjMbbK05pimERhBQjjnRxbowFy8IeAY0P9Sv6P/YUGMzdtTuynU/V1DxTkOl7266urpG6nJKplrM5SvHL31T6nNjPK8xxi2zHZNFlwOGUIQmeyPHooW3nZZPfdI5GSntUtVkjxyEWMS8NeUPCSgAD1jaOqnaTffgB6u1L6OCuoOn44tiGLVVdcwyNzlISttDHhxqAmSZqncdFLq+z2O2XkDV3JGvxsoRZJvGzEJsoBNNtJ7e4yfHqaGX/f9T8yxok+sxa3SJqBCToJ/Xf0B5AgMBAAGjYjBgMB0GA1UdDgQWBBTisFhrVOekTsPbefbUyZvtacDTgTAJBgNVHRMEAjAAMA4GA1UdDwEB/wQEAwIGwDARBgNVHSAECjAIMAYGBFUdIAAwEQYDVR0lBAowCAYGBACRNwMAMA0GCSqGSIb3DQEBDQUAA4ICAQATZuB0BpxCq4RVJq00ombHwBuJXCeI7vVtcIbotX2q7fb6ZM8Y1GasvXrB5C/nIwQ4hjta4k/pV4sL0VmZNcYUZq7ycDW7Pc9ZW6jVYpPSYONbmi43YDZ5QfmHUnr0aQqb6fm7I97OThcFgeCLUAf98TQ6uxs9x2SrkE1wYjqtSLE/IZ+W6vceNMsZv9a7BMr7MXOBTum9u6SPrSvF0zxhOgKQ8AoVY+uQgnXB5Tlh7T8UmqzeiBHUKbQrY1+KyCq3eqYiRUbEKixnoitGxtnRjSUj+NJIh+z9DhQTtLY5Xqa4rCpbNrEzoRHENInkHYSg3VnDj0vkjcvqIZT+rtL21M0pvDOulJnO8AhsjB8p7KM74d+KuMy3KX2iQlV2hvZGxDg/nng2pto12uDnWunmAfPRTzn59KHZbhSPKT/ZwMDw/3RDH/8N+G6PbIjArDBuO88EgF9ExxkDHdLWossOhm/xCanEmaVVdFNUj5gwGDYhOa1SDzZ9PxW2tp1heMmY++N0zNJ9PRj+ASsJArCwQ8uRBdKOV2yyDvdLvZkA3KWa/aRD5UHF5eksd/Uz2YSM+2S0luyMDjNkEk9VGy5+K6YrdZXuhPft+ph0/MouYhQYnF6r/QpJuYe8zrdxwKIoLRh6uMrq+IEVNFNxkpPglwj2zgUuIZxX6N6qJarphA==2026-08-21T09:20:49Z3kWWlv2DNx7+A3DDyOsrCBn7BEGaE0+u8134BdJU2I3K/UDaN5nucAzIY6HPnoE0MQM9yAxQwSrQD/umxGZyZA==MF8wVqRUMFIxCzAJBgNVBAYTAkZJMScwJQYDVQQKDB5MaWlrZW5uZS0gamEgdmllc3RpbnTDpHZpcmFzdG8xGjAYBgNVBAMMEVNjaGVtZU9wZXJhdG9yIElJAgUUq76fiw==text/xml \ No newline at end of file From c468681f53d0800cccaa8f6b2cdc22a796ae203f Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Fri, 11 Sep 2026 03:33:47 +0200 Subject: [PATCH 2/8] docs(seal): name the XMLDSig candidates rather than imply none --- crates/dpp-seal/src/trustlist/mod.rs | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index 49035de3..2c5bf75d 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -13,11 +13,18 @@ //! against the scheme operator's certificate, is what makes it evidence rather //! than a file from a web server. **This module does not check it.** //! -//! Verifying one needs XML Signature with canonicalisation, which has no mature -//! Rust implementation — the EU's own validator is a Java application. Writing -//! one is a serious piece of work in its own right, and canonicalisation is -//! exactly where subtle signature-verification bugs live. So it is not attempted -//! here, and the gap is named rather than glossed. +//! Verifying one needs XML Signature over the **canonicalised** subtree, which +//! is where subtle signature-verification bugs live: a canonicaliser that +//! differs from the signer's in any edge case either rejects valid documents or, +//! worse, accepts one whose signed portion is not what the verifier thinks it +//! is. +//! +//! Rust has candidates rather than a settled answer — `xml-sec` is a young +//! pure-Rust implementation, `xml_c14n` binds libxml2 for the canonicalisation +//! half, and the EU's own reference validator is a Java application. Choosing +//! between them is a real decision with a deployment cost attached, not a +//! dependency to add in passing, so it is not made here. The gap is named rather +//! than glossed. //! //! What follows from that is a hard boundary, and it is built into the type //! names: [`UnverifiedTrustedList`] is what parsing produces, and nothing in From 512c205170fd361dd7ed823147cd93a9d86d137e Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Fri, 11 Sep 2026 04:02:43 +0200 Subject: [PATCH 3/8] docs(seal): pin the xml-sec fork for whoever implements verification --- crates/dpp-seal/src/trustlist/mod.rs | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index 2c5bf75d..1f0bc8f9 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -26,6 +26,28 @@ //! dependency to add in passing, so it is not made here. The gap is named rather //! than glossed. //! +//! ## For whoever implements it +//! +//! `xml-sec` has been evaluated against the real corpus and **verifies every +//! reachable EU trusted list**, rejecting single-byte tampering in signed +//! content and inside the XAdES `SignedProperties` alike. Two national lists +//! (Italy, France) exceed a hard-coded node-set ceiling in the published crate; +//! a fork carrying the one-constant fix is pinned and ready: +//! +//! ```toml +//! # workspace Cargo.toml — remove once the upstream fix ships +//! [patch.crates-io] +//! xml-sec = { git = "https://github.com/odal-node/xml-sec.git", rev = "7daf6028e08bc17f60ac36833d90c9307ca25449" } +//! ``` +//! +//! It is deliberately **not** wired in yet: a patch for a crate nothing depends +//! on is a build warning, and verifying a signature against a certificate the +//! document itself carries would prove nothing. The missing half is the trust +//! anchor, and it is not a CA — the list of lists is anchored on certificates +//! published in the Official Journal, C series, so they have to be pinned from +//! that notice and refreshed when the Commission republishes it. That design +//! comes first. +//! //! What follows from that is a hard boundary, and it is built into the type //! names: [`UnverifiedTrustedList`] is what parsing produces, and nothing in //! this crate turns it into a verdict. From e2e50f6003ccc9f285263eff01caeca0b2726370 Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Fri, 11 Sep 2026 04:17:32 +0200 Subject: [PATCH 4/8] feat(seal): pin the EU trusted list trust anchor --- crates/dpp-seal/src/trustlist/anchor.rs | 179 ++++++++++++++++++ crates/dpp-seal/src/trustlist/anchor_tests.rs | 102 ++++++++++ crates/dpp-seal/src/trustlist/mod.rs | 22 ++- .../tests/fixtures/eu-lotl-signing-cert.der | Bin 0 -> 2212 bytes 4 files changed, 297 insertions(+), 6 deletions(-) create mode 100644 crates/dpp-seal/src/trustlist/anchor.rs create mode 100644 crates/dpp-seal/src/trustlist/anchor_tests.rs create mode 100644 crates/dpp-seal/tests/fixtures/eu-lotl-signing-cert.der diff --git a/crates/dpp-seal/src/trustlist/anchor.rs b/crates/dpp-seal/src/trustlist/anchor.rs new file mode 100644 index 00000000..8c757008 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/anchor.rs @@ -0,0 +1,179 @@ +//! The pinned root of trust for the EU list of trusted lists. + +use base64::Engine as _; +use sha2::{Digest as _, Sha256}; + +/// The certificates authorised to sign the EU list of trusted lists, as +/// **SHA-256 digests**, together with the Official Journal notice they were +/// taken from. +/// +/// # Why digests and not certificates +/// +/// The Commission publishes the LOTL-signing certificates in the Annex of an +/// Official Journal C-series notice, in PEM, **each with its SHA-256 and SHA-1 +/// digest**. Publishing the digests is the hint: the certificate itself arrives +/// inside the LOTL's `ds:KeyInfo`, so a relying party does not need to carry it — +/// only to *recognise* it. +/// +/// That makes the entire pinned trust root six base64 strings. It fits on a +/// screen, it diffs legibly in review, and it cannot be mistaken for a +/// certificate store that something might try to build a path through. +/// +/// # Why this is compiled in and not configuration +/// +/// This is the one value in the system that must not be settable by deployment. +/// An operator — or anything that can write the operator's configuration — that +/// can repoint the anchor can make *any* trusted list verify, and with it any +/// claim of qualified status that rests on one. Configuration is for choices +/// about a deployment; this is the thing the deployment is trusted *against*. +/// +/// It is the same reasoning [`crate::config`] applies to `SEAL_PROVIDER` — a +/// node that cannot name its trust provider must not quietly become one that has +/// none — carried to its root. Changing the anchor is a reviewed commit and a +/// release, and that is the feature, not the friction. +#[derive(Debug, Clone, Copy)] +pub struct LotlAnchor { + /// Base64 SHA-256 digests of the authorised certificates, exactly as the + /// notice prints them. + digests: &'static [&'static str], + /// Where the LOTL is published, as the same notice states it. + /// + /// Pinned alongside the digests because the Commission may change it too, + /// and a correct certificate presented from an unexpected location is not + /// something to accept quietly. + location: &'static str, + /// CELEX of the notice these came from. + /// + /// Carried so provenance lives in the source rather than in someone's + /// memory of where the numbers were copied from. + notice_celex: &'static str, + /// The notice's ELI, for a reader who wants to check the Annex. + notice_uri: &'static str, + /// When this pin was taken from that notice. + pinned_on: &'static str, +} + +/// The anchor in force, from Official Journal notice CELEX `52026XC01944`. +/// +/// *"Compilation of Member States' trusted lists as notified under Commission +/// Implementing Decision (EU) 2015/1505 as amended by Commission Implementing +/// Decision (EU) 2025/2164"*. +/// +/// # Verified when pinned +/// +/// All six digests were checked against the live LOTL on 2026-09-11: the +/// document's EU self-pointer declares six certificates, and every one hashes to +/// a digest below. The certificate then signing the LOTL hashed to the second. +/// +/// # Refreshing this +/// +/// The Commission republishes the notice when the certificates or the location +/// change. There is no push, and a stale pin **fails closed** — nothing verifies, +/// which will present as an outage rather than as a warning. +/// +/// The early signal is in the LOTL itself: the first entry of its +/// `SchemeInformationURI` is the notice currently in force, so a node can notice +/// that [`Self::notice_uri`] no longer matches and say so *before* the +/// certificates change under it. +/// +/// To refresh: open the notice, take the SHA-256 **base64** digests from the +/// Annex — never the SHA-1 ones, which are published for legacy tooling — and +/// replace the list below along with the CELEX, the URI and the date. +pub const EU_LOTL_ANCHOR: LotlAnchor = LotlAnchor { + digests: &[ + "wGQcT31WxDGxySR0Lbf86cHu99f9ISETonaEhrOrzcU=", + "4KYg+7Z0c2K7kzrEQWnWdqVTREcWz18xYF8SoiuDlrE=", + "334pNgw0srjW1fQDJcHU0SyZIs7NM7dAdnSnSys8oeU=", + "tj1BZ0TnCYv57CyqWWqTvCRo43+ChLpl7MBhcRvLqhg=", + "I2ED8DqAMa6PR/kFm/jeOFZM2/6+3eSll9UPiYCqZTs=", + "0gZP3XD2mC3MUWuG2dXFauqTlBfGJLLkeMCyneVPhHQ=", + ], + location: "https://ec.europa.eu/tools/lotl/eu-lotl.xml", + notice_celex: "52026XC01944", + notice_uri: "https://eur-lex.europa.eu/eli/C/2026/1944/oj", + pinned_on: "2026-09-11", +}; + +impl LotlAnchor { + /// Whether the Official Journal authorises this certificate to sign the LOTL. + /// + /// `certificate_der` is the DER the document carried — base64-decoded, not + /// the base64 text. + /// + /// # 🚩 Necessary, and nowhere near sufficient + /// + /// A `true` here means *"the Official Journal names this certificate"*. It + /// does **not** mean the document is authentic, and the two are easy to + /// conflate at a call site. + /// + /// Anyone can copy the genuine LOTL's `ds:KeyInfo` certificate into a forged + /// document; the forgery would satisfy this check and be a forgery still. + /// What separates them is the **signature**, verified with this certificate + /// over the canonicalised document — and that is a different function. + /// + /// So this is a precondition to run *before* verifying a signature, to + /// establish that the key about to be trusted is one the Union published. It + /// is never the verdict. + #[must_use] + pub fn authorises(&self, certificate_der: &[u8]) -> bool { + let digest = + base64::engine::general_purpose::STANDARD.encode(Sha256::digest(certificate_der)); + self.digests.contains(&digest.as_str()) + } + + /// Whether this is the location the notice publishes the LOTL at. + /// + /// Compared rather than assumed because the Commission may move it, and the + /// move is announced in the same notice as a certificate change. A LOTL + /// fetched from somewhere else may be perfectly genuine and still not be the + /// one this anchor describes. + #[must_use] + pub fn is_pinned_location(&self, url: &str) -> bool { + self.location == url + } + + /// Where the notice says the LOTL is published. + #[must_use] + pub const fn location(&self) -> &'static str { + self.location + } + + /// CELEX of the Official Journal notice this pin came from. + #[must_use] + pub const fn notice_celex(&self) -> &'static str { + self.notice_celex + } + + /// ELI of that notice. + /// + /// Compare against the **first** entry of a fetched LOTL's + /// `SchemeInformationURI`: that entry is the notice currently in force, so a + /// mismatch means this pin has been superseded and should be refreshed + /// before the certificates rotate underneath it. + #[must_use] + pub const fn notice_uri(&self) -> &'static str { + self.notice_uri + } + + /// The date this pin was taken from the notice. + #[must_use] + pub const fn pinned_on(&self) -> &'static str { + self.pinned_on + } + + /// How many certificates the notice authorises. + #[must_use] + pub const fn authorised_count(&self) -> usize { + self.digests.len() + } + + /// The raw pinned digests, for this crate's own tests. + /// + /// Deliberately not public. A caller with the digest list can only + /// reimplement [`Self::authorises`], and a second implementation of the + /// trust decision is the last thing this type should make easy. + #[cfg(test)] + pub(crate) const fn digests_for_test(&self) -> &'static [&'static str] { + self.digests + } +} diff --git a/crates/dpp-seal/src/trustlist/anchor_tests.rs b/crates/dpp-seal/src/trustlist/anchor_tests.rs new file mode 100644 index 00000000..6d44a343 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/anchor_tests.rs @@ -0,0 +1,102 @@ +//! The pinned anchor, against the certificate that really signs the LOTL. + +use super::anchor::EU_LOTL_ANCHOR; + +/// The DER of the certificate that signed the EU list of trusted lists when this +/// pin was taken, lifted from its `ds:KeyInfo`. +/// +/// Subject `EUROPEAN COMMISSION`, OU *Directorate-General for Digital Services +/// (DIGIT)*, issued by a Portuguese qualified trust service provider and valid +/// 2023-11-17 to 2027-11-17. +/// +/// A real certificate rather than one generated for the test, because the claim +/// under test is about the real world: that the digests transcribed from the +/// Official Journal actually match what the Commission signs with. A generated +/// certificate could only prove the hash function works. +const LOTL_SIGNING_CERT: &[u8] = include_bytes!("../../tests/fixtures/eu-lotl-signing-cert.der"); + +/// The certificate that signs the real LOTL is one the Official Journal names. +/// +/// The transcription check. Six digests were copied out of a notice by hand, and +/// this is what catches a wrong character in any of them — without it, the +/// anchor could be subtly wrong and nothing would say so until a verification +/// that should have passed did not. +#[test] +fn the_real_lotl_signing_certificate_is_authorised() { + assert!( + EU_LOTL_ANCHOR.authorises(LOTL_SIGNING_CERT), + "the certificate signing the published LOTL must be one the notice at {} names", + EU_LOTL_ANCHOR.notice_celex() + ); +} + +/// Nothing else is authorised. +/// +/// Guards the direction that matters. An `authorises` that returned `true` +/// broadly would pass the test above and defeat the anchor entirely, so a +/// near-miss is checked explicitly: the same certificate with one byte changed +/// is a different certificate and must be refused. +#[test] +fn a_certificate_the_notice_does_not_name_is_refused() { + assert!(!EU_LOTL_ANCHOR.authorises(b"")); + assert!(!EU_LOTL_ANCHOR.authorises(b"not a certificate")); + + let mut tampered = LOTL_SIGNING_CERT.to_vec(); + let last = tampered.len() - 1; + tampered[last] ^= 0x01; + assert!( + !EU_LOTL_ANCHOR.authorises(&tampered), + "one flipped bit makes it a different certificate" + ); +} + +/// The anchor carries its own provenance. +/// +/// Asserted because these are the fields someone refreshing the pin has to +/// update together, and a stale CELEX beside fresh digests would misreport where +/// the trust came from — the one thing the provenance exists to prevent. +#[test] +fn the_anchor_states_where_it_came_from() { + assert_eq!(EU_LOTL_ANCHOR.notice_celex(), "52026XC01944"); + assert!( + EU_LOTL_ANCHOR.notice_uri().contains("eli/C/2026/1944"), + "the ELI and the CELEX must name the same notice" + ); + assert_eq!( + EU_LOTL_ANCHOR.authorised_count(), + 6, + "the notice's Annex carries six certificates" + ); + assert_eq!(EU_LOTL_ANCHOR.pinned_on(), "2026-09-11"); +} + +/// The pinned location is compared, not assumed. +#[test] +fn only_the_pinned_location_matches() { + assert!(EU_LOTL_ANCHOR.is_pinned_location("https://ec.europa.eu/tools/lotl/eu-lotl.xml")); + assert!( + !EU_LOTL_ANCHOR.is_pinned_location("https://example.test/eu-lotl.xml"), + "a LOTL from elsewhere may be genuine and is still not the one this anchor describes" + ); + assert!( + !EU_LOTL_ANCHOR.is_pinned_location("http://ec.europa.eu/tools/lotl/eu-lotl.xml"), + "and the scheme is part of the location" + ); +} + +/// Every pinned digest is a well-formed base64 SHA-256. +/// +/// A transcription slip that produced a string of the wrong length would +/// otherwise sit in the list matching nothing, silently shrinking the authorised +/// set — which fails closed, but fails closed for a reason nobody would find. +#[test] +fn every_pinned_digest_is_a_base64_sha256() { + use base64::Engine as _; + + for digest in EU_LOTL_ANCHOR.digests_for_test() { + let raw = base64::engine::general_purpose::STANDARD + .decode(digest) + .unwrap_or_else(|e| panic!("{digest} is not base64: {e}")); + assert_eq!(raw.len(), 32, "{digest} is not a 32-byte SHA-256 digest"); + } +} diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index 1f0bc8f9..a09bcefd 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -41,12 +41,18 @@ //! ``` //! //! It is deliberately **not** wired in yet: a patch for a crate nothing depends -//! on is a build warning, and verifying a signature against a certificate the -//! document itself carries would prove nothing. The missing half is the trust -//! anchor, and it is not a CA — the list of lists is anchored on certificates -//! published in the Official Journal, C series, so they have to be pinned from -//! that notice and refreshed when the Commission republishes it. That design -//! comes first. +//! on is a build warning. +//! +//! The other half — knowing *which* key to trust — is done. [`EU_LOTL_ANCHOR`] +//! pins the certificates the Official Journal authorises to sign the list of +//! lists, so a verifier has something to check the signing certificate against +//! rather than trusting whichever one the document happens to carry. Read +//! [`LotlAnchor::authorises`] before using it: it is a precondition, never a +//! verdict. +//! +//! What remains is to run the two together — establish the certificate is +//! anchored, then verify the signature with it, then verify each national list +//! against the certificates the now-verified LOTL names for that territory. //! //! What follows from that is a hard boundary, and it is built into the type //! names: [`UnverifiedTrustedList`] is what parsing produces, and nothing in @@ -76,12 +82,16 @@ //! so a present-tense answer is the wrong answer to the question that matters, //! in both directions. +mod anchor; +#[cfg(test)] +mod anchor_tests; mod fetch; mod model; mod parse; #[cfg(test)] mod tests; +pub use anchor::{EU_LOTL_ANCHOR, LotlAnchor}; pub use fetch::{ EU_LOTL_URL, MAX_TRUSTED_LIST_BYTES, fetch_lotl_pointers, fetch_trusted_list, national_pointers, }; diff --git a/crates/dpp-seal/tests/fixtures/eu-lotl-signing-cert.der b/crates/dpp-seal/tests/fixtures/eu-lotl-signing-cert.der new file mode 100644 index 0000000000000000000000000000000000000000..662233c36424895f2bdf7e57d3cb954ca52ffc32 GIT binary patch literal 2212 zcmbVNeK?fq8lU%_*D#Ea7(?0x4I>7R1Dpz4&6OAX>oVMkR>3xbVhKyUSxnXz zhA*4N^d|>#7{06xto7bxF9w;30!tI!l};#%x}pF@on1neqU!pg18~Amo!B$U%u*p^^+g>R+^!b_a5RIEEW9*vFL$65>%e;QAf}cnidQ zo>a+O%6DM$P8+ozJ836U7N4uJWS>!Tu!(kij+!9}CjJU}dmAMyc0^WiW&}b9|4%$GL|V83vVE z%7R=9`hUp5{q8ImLpP>$#5;p2nsKkw$)-1odfvcQrAL<6Y#d3O(jVb{vkubWr_Ky# z+iPk*JG1p0!^{?|F3Q`R>|PmFYT>puqxn}PH`T&8HY}Q6*mi*wd@gsQi=nCUgOABk zp27*Un^2Tq)qokat2_C~*;hXWRTo=^LSMIDyic*6#taS12jDTDahN1=?uCxk<>g6l@Dbj{;rQ&S6*dV6 zGoHCuu3m~Z-+N^~y?v%&T>EfYaN&1f?bLf{+wJ!SLiGt~IMXc6Ime9Lyts)yYY?^j zmWaD;%U7st@)PahrC+vqPiu|god(RasYC&>mE4bgJJzN*JA1k3+P!4+UB^eX`e;=y zHU4e(9T6`vJN9?ixlgl0p4-$mx&Jtuy!J5T;iaTTyF>M!`R9=+w<5in6{B}9i>y0b zcAf~W^z`$3+9O{zF=DZ|=3Z^%gX*4$F-@!Sa^b+E%+}LZP_L%*InqaoRNbP=f~w3l ze!B#`kysrf?)jt~4m`nMJ=itjIytrN>9ASt>?L;M&lXtIk6|o?fxec(h02a700d<_ zS{Oml90CIjuu@4B#1xPY5hbh%x;YU^DKtFz#_?8I48`;r5u|0{v_8T?8XB4qgzN)* zzy`Gp;0*U&QmIJd?&!Fi$90H7Y46&XE0ic#0Zk-zTrlnP!|ugkqBN0fB%saXKp8gw z9VdY&5xtu=i$#bTFirapV*-vqHSVIzTV+Eb;iipO+^VzAu#?LPCgnFSxCW)VYem8b#yul`qK2 za#k_WQ^nF(bs?fGA${TgQvPg|`wPO9O`cVxyVh^KIxDg=oTR_1A4n@c7CnA3UDBUw z?O#gWPje!R9gk}@>mc6auVHBvJ!b9J9qi%|DB`C>hmhq>orqZe0D>e?fmtm6&K zOxKzf7z!#bCo#6>m3_}>R0iKp9`C0Q7VU?}#iC!iFA5ubo_^AOd#8QeJ|jdY z#U!i~U%e#T&rZ@_M7(=L+w{P6YjQ!~o>NCb^pY>}jH7~zYZ+oxTXkT|OE0|vP zePGr)&+=Dy9{0wD2J)>PBd0@b8QGlCCd;wG*mfa#qj Date: Fri, 11 Sep 2026 04:28:15 +0200 Subject: [PATCH 5/8] feat(seal): verify the list of trusted lists against the anchor --- Cargo.lock | 947 +++++-- Cargo.toml | 7 + crates/dpp-seal/Cargo.toml | 5 + crates/dpp-seal/src/trustlist/anchor.rs | 4 +- crates/dpp-seal/src/trustlist/mod.rs | 115 +- crates/dpp-seal/src/trustlist/verify.rs | 206 ++ crates/dpp-seal/src/trustlist/verify_tests.rs | 135 + crates/dpp-seal/tests/fixtures/eu-lotl.xml | 2176 +++++++++++++++++ 8 files changed, 3365 insertions(+), 230 deletions(-) create mode 100644 crates/dpp-seal/src/trustlist/verify.rs create mode 100644 crates/dpp-seal/src/trustlist/verify_tests.rs create mode 100644 crates/dpp-seal/tests/fixtures/eu-lotl.xml diff --git a/Cargo.lock b/Cargo.lock index fb52be69..0f81b8d5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,13 +2,22 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "addr2line" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b" +dependencies = [ + "gimli 0.32.3", +] + [[package]] name = "addr2line" version = "0.26.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a" dependencies = [ - "gimli", + "gimli 0.33.0", ] [[package]] @@ -40,16 +49,26 @@ dependencies = [ [[package]] name = "aes-gcm" -version = "0.11.0" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fdf011db2e21ce0d575593d749db5554b47fed37aff429e4dc50bc91ac93a028" +checksum = "7f2b8006a0c83f52b62ba44a97b58bf76fe2f70a329e588f67f89691d93d498f" dependencies = [ "aead", "aes", "cipher", "ctr", + "ctutils", "ghash", - "subtle", +] + +[[package]] +name = "aes-kw" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41ac571010bd60765c56085a4f1d412012a9be2663b1a2f2b19b49318653fd0d" +dependencies = [ + "aes", + "const-oid 0.10.2", ] [[package]] @@ -255,8 +274,8 @@ version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "synstructure", ] @@ -267,8 +286,8 @@ version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -365,8 +384,8 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -387,8 +406,8 @@ version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -398,8 +417,8 @@ version = "0.1.91" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae36dc4177970ef04fde5178d3e2429882def40e57a451f919c098f72baa6cec" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -546,13 +565,13 @@ dependencies = [ "aws-smithy-runtime-api", "aws-smithy-types", "bytes", - "crypto-bigint", + "crypto-bigint 0.5.5", "form_urlencoded", "hex", "hmac 0.13.0", "http 0.2.12", "http 1.5.0", - "p256", + "p256 0.13.2", "percent-encoding", "sha2 0.11.0", "subtle", @@ -720,8 +739,8 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "221eaa237ddf1ca79b60d1372aad77e47f9c0ea5b3ce5099da8c61d027dc77b3" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -849,8 +868,8 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7aa268c23bfbbd2c4363b9cd302a4f504fb2a9dfe7e3451d66f35dd392e20aca" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -863,12 +882,33 @@ dependencies = [ "fastrand", ] +[[package]] +name = "backtrace" +version = "0.3.76" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6" +dependencies = [ + "addr2line 0.25.1", + "cfg-if", + "libc", + "miniz_oxide", + "object 0.37.3", + "rustc-demangle", + "windows-link", +] + [[package]] name = "base16ct" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" +[[package]] +name = "base16ct" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6" + [[package]] name = "base64" version = "0.22.1" @@ -957,6 +997,15 @@ dependencies = [ "hybrid-array", ] +[[package]] +name = "block-padding" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "710f1dd022ef4e93f8a438b4ba958de7f64308434fa6a87104481645cc30068b" +dependencies = [ + "hybrid-array", +] + [[package]] name = "block2" version = "0.6.2" @@ -1193,6 +1242,15 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" +[[package]] +name = "cbc" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce2dc9ee5f88d11e0beb842c88b33c8a5cf0d1329c4b19494af42b07dbfe8896" +dependencies = [ + "cipher", +] + [[package]] name = "cc" version = "1.4.1" @@ -1309,8 +1367,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061" dependencies = [ "heck", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -1342,9 +1400,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b77c319abfd5219629c45c34c89ba945ed3c5e49fcde9d16b6c3885f118a730" dependencies = [ "const-oid 0.9.6", - "der", - "spki", - "x509-cert", + "der 0.7.10", + "spki 0.7.3", + "x509-cert 0.2.5", ] [[package]] @@ -1537,7 +1595,7 @@ dependencies = [ "cranelift-control", "cranelift-entity", "cranelift-isle", - "gimli", + "gimli 0.33.0", "hashbrown 0.17.1", "libm", "log", @@ -1777,6 +1835,23 @@ dependencies = [ "zeroize", ] +[[package]] +name = "crypto-bigint" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a52aa3fcda4e6302a9f48734f234d35d4721b96f8fe07d073f07ce9df4f0271" +dependencies = [ + "cpubits", + "ctutils", + "getrandom 0.4.3", + "hybrid-array", + "num-traits", + "rand_core 0.10.1", + "serdect", + "subtle", + "zeroize", +] + [[package]] name = "crypto-common" version = "0.1.7" @@ -1798,6 +1873,16 @@ dependencies = [ "rand_core 0.10.1", ] +[[package]] +name = "crypto-primes" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3633a51a39c69ebbaa4feaa694bd83d241e4093901c84a0963b19d9bb3f0cf8f" +dependencies = [ + "crypto-bigint 0.7.5", + "rand_core 0.10.1", +] + [[package]] name = "csv" version = "1.4.0" @@ -1835,6 +1920,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e" dependencies = [ "cmov", + "subtle", ] [[package]] @@ -1875,8 +1961,8 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -1897,8 +1983,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0" dependencies = [ "ident_case", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "strsim", "syn 2.0.119", ] @@ -1910,7 +1996,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d" dependencies = [ "darling_core", - "quote", + "quote 1.0.47", "syn 2.0.119", ] @@ -1963,9 +2049,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" dependencies = [ "const-oid 0.9.6", - "der_derive", + "der_derive 0.7.3", "flagset", - "pem-rfc7468", + "pem-rfc7468 0.7.0", + "zeroize", +] + +[[package]] +name = "der" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a878c850e9e421b20262e9b41f9c860e4785fa07541c266b62ff9d1ef998a80a" +dependencies = [ + "const-oid 0.10.2", + "der_derive 0.8.0", + "flagset", + "pem-rfc7468 1.0.0", "zeroize", ] @@ -1989,8 +2088,19 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", + "syn 2.0.119", +] + +[[package]] +name = "der_derive" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59600e2c2d636fde9b65e99cc6445ac770c63d3628195ff39932b8d6d7409903" +dependencies = [ + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -2019,12 +2129,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb" dependencies = [ "convert_case", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "rustc_version", "syn 2.0.119", ] +[[package]] +name = "des" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "916a94e407b54f9034d71dd748234cd1e516ced6284009906ae246f177eafe5a" +dependencies = [ + "cipher", +] + [[package]] name = "digest" version = "0.10.7" @@ -2088,11 +2207,17 @@ version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] +[[package]] +name = "doc-comment" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "780955b8b195a21ab8e4ac6b60dd1dbdcec1dc6c51c0617964b08c81785e12c9" + [[package]] name = "docker_credential" version = "1.4.0" @@ -2544,12 +2669,12 @@ dependencies = [ "chrono", "cms", "const-oid 0.9.6", - "der", + "der 0.7.10", "dpp-common", "dpp-domain", "hex", "hmac 0.13.0", - "p256", + "p256 0.13.2", "rcgen", "reqwest", "roxmltree", @@ -2561,7 +2686,8 @@ dependencies = [ "tokio", "tracing", "url", - "x509-cert", + "x509-cert 0.2.5", + "xml-sec", "zeroize", ] @@ -2658,6 +2784,24 @@ dependencies = [ "thiserror 2.0.20", ] +[[package]] +name = "dsa" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c8573b60d07b5b5cecadc1f978c9b71d5504151e703cbb0439ee4ad301338f3" +dependencies = [ + "crypto-bigint 0.7.5", + "crypto-common 0.2.2", + "crypto-primes", + "der 0.8.2", + "digest 0.11.3", + "pkcs8 0.11.0", + "rfc6979 0.6.0", + "sha2 0.11.0", + "signature 3.0.0", + "zeroize", +] + [[package]] name = "dunce" version = "1.0.5" @@ -2676,12 +2820,27 @@ version = "0.16.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" dependencies = [ - "der", + "der 0.7.10", "digest 0.10.7", - "elliptic-curve", - "rfc6979", + "elliptic-curve 0.13.8", + "rfc6979 0.4.0", "signature 2.2.0", - "spki", + "spki 0.7.3", +] + +[[package]] +name = "ecdsa" +version = "0.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0681a4fc24c767085329728d8dfba959af91228aa4610cca4f8ce317ba46ae0" +dependencies = [ + "der 0.8.2", + "digest 0.11.3", + "elliptic-curve 0.14.1", + "rfc6979 0.6.0", + "signature 3.0.0", + "spki 0.8.0", + "zeroize", ] [[package]] @@ -2699,6 +2858,7 @@ version = "3.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "29fcf32e6c73d1079f83ab4d782de2d81620346a5f38c6237a86a22f8368980a" dependencies = [ + "pkcs8 0.11.0", "signature 3.0.0", ] @@ -2745,16 +2905,37 @@ version = "0.13.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" dependencies = [ - "base16ct", - "crypto-bigint", + "base16ct 0.2.0", + "crypto-bigint 0.5.5", "digest 0.10.7", - "ff", + "ff 0.13.1", "generic-array", - "group", - "pem-rfc7468", - "pkcs8", + "group 0.13.0", + "pem-rfc7468 0.7.0", + "pkcs8 0.10.2", "rand_core 0.6.4", - "sec1", + "sec1 0.7.3", + "subtle", + "zeroize", +] + +[[package]] +name = "elliptic-curve" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d65aa39b3a5c1c9c1b745c9a019234bb7a21b77abcb4f4d266d706e2d577d65" +dependencies = [ + "base16ct 1.0.0", + "crypto-bigint 0.7.5", + "crypto-common 0.2.2", + "digest 0.11.3", + "ff 0.14.0", + "group 0.14.0", + "hybrid-array", + "pem-rfc7468 1.0.0", + "pkcs8 0.11.0", + "rand_core 0.10.1", + "sec1 0.8.1", "subtle", "zeroize", ] @@ -2817,8 +2998,8 @@ version = "0.7.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -2932,6 +3113,16 @@ dependencies = [ "subtle", ] +[[package]] +name = "ff" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1f686ab92a9fb0eaf188f6c6c87b89490baa6fdb0db4544ba4dc47f7942489f" +dependencies = [ + "rand_core 0.10.1", + "subtle", +] + [[package]] name = "fiat-crypto" version = "0.2.9" @@ -3115,8 +3306,8 @@ version = "0.3.33" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2d6d3cde68c518367be28956066ddfef33813991b77a55005a69dae04bf3b10b" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -3165,8 +3356,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c5a7e0eb46f83a20260b850117d204366674e85d3a908d90865c78df9a6b1dfc" dependencies = [ "g2poly", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -3262,6 +3453,12 @@ dependencies = [ "polyval", ] +[[package]] +name = "gimli" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7" + [[package]] name = "gimli" version = "0.33.0" @@ -3280,11 +3477,22 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" dependencies = [ - "ff", + "ff 0.13.1", "rand_core 0.6.4", "subtle", ] +[[package]] +name = "group" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fd1a1c7a5206c5b7a3f5a0d7ccd3ff85d0c8f5133d62a02680255b0004af5f4" +dependencies = [ + "ff 0.14.0", + "rand_core 0.10.1", + "subtle", +] + [[package]] name = "h2" version = "0.4.16" @@ -3487,7 +3695,9 @@ version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b" dependencies = [ + "subtle", "typenum", + "zeroize", ] [[package]] @@ -3787,6 +3997,7 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7" dependencies = [ + "block-padding", "hybrid-array", ] @@ -3885,8 +4096,8 @@ version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "rustc_version", "simd_cesu8", "syn 2.0.119", @@ -3907,7 +4118,7 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264" dependencies = [ - "quote", + "quote 1.0.47", "syn 2.0.119", ] @@ -4493,6 +4704,15 @@ dependencies = [ "objc2-core-foundation", ] +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + [[package]] name = "object" version = "0.39.1" @@ -4566,12 +4786,53 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" dependencies = [ - "ecdsa", - "elliptic-curve", - "primeorder", + "ecdsa 0.16.9", + "elliptic-curve 0.13.8", + "primeorder 0.13.6", "sha2 0.10.9", ] +[[package]] +name = "p256" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2c9239b2dbc807adbbe147e8cf72ea7450c3a0aabe62cb8e75ff4ec22e1f72a" +dependencies = [ + "ecdsa 0.17.0", + "elliptic-curve 0.14.1", + "primefield", + "primeorder 0.14.0", + "sha2 0.11.0", +] + +[[package]] +name = "p384" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d17b851e6b3e378ab4ecb07fa2ed23f4d15f075735f8fec9fa1e7bdce5f8301f" +dependencies = [ + "ecdsa 0.17.0", + "elliptic-curve 0.14.1", + "fiat-crypto 0.3.0", + "primefield", + "primeorder 0.14.0", + "sha2 0.11.0", +] + +[[package]] +name = "p521" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ad64cc32c2dc466317c12ee5853e61f159f9eab1fe7efade0395dc2e7b43449" +dependencies = [ + "base16ct 1.0.0", + "ecdsa 0.17.0", + "elliptic-curve 0.14.1", + "primefield", + "primeorder 0.14.0", + "sha2 0.11.0", +] + [[package]] name = "page_size" version = "0.6.0" @@ -4628,8 +4889,8 @@ version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2ae7800a4c974efd12df917266338e79a7a74415173caf7e70aa0a0707345281" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "regex", "regex-syntax", "structmeta", @@ -4646,6 +4907,16 @@ dependencies = [ "phc", ] +[[package]] +name = "pbkdf2" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629" +dependencies = [ + "digest 0.11.3", + "hmac 0.13.0", +] + [[package]] name = "pem" version = "3.0.6" @@ -4656,6 +4927,16 @@ dependencies = [ "serde_core", ] +[[package]] +name = "pem" +version = "4.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d354a98a3d1251555de99e8fdd8afda05573c31b82f59063a7b0a29b5527f120" +dependencies = [ + "base64 0.23.1", + "serde_core", +] + [[package]] name = "pem-rfc7468" version = "0.7.0" @@ -4665,12 +4946,27 @@ dependencies = [ "base64ct", ] +[[package]] +name = "pem-rfc7468" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9" +dependencies = [ + "base64ct", +] + [[package]] name = "percent-encoding" version = "2.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" +[[package]] +name = "peresil" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f658886ed52e196e850cfbbfddab9eaa7f6d90dd0929e264c31e5cec07e09e57" + [[package]] name = "phc" version = "0.6.1" @@ -4697,8 +4993,8 @@ version = "1.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -4714,14 +5010,53 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" +[[package]] +name = "pkcs1" +version = "0.8.0-rc.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "986d2e952779af96ea048f160fd9194e1751b4faea78bcf3ceb456efe008088e" +dependencies = [ + "der 0.8.2", + "spki 0.8.0", +] + +[[package]] +name = "pkcs5" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63d440a804ec8d6fafbb6b84471e013286658d373248927692ab3366686220ca" +dependencies = [ + "aes", + "aes-gcm", + "cbc", + "der 0.8.2", + "pbkdf2", + "rand_core 0.10.1", + "scrypt", + "sha2 0.11.0", + "spki 0.8.0", +] + [[package]] name = "pkcs8" version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" dependencies = [ - "der", - "spki", + "der 0.7.10", + "spki 0.7.3", +] + +[[package]] +name = "pkcs8" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "451913da69c775a56034ea8d9003d27ee8948e12443eae7c038ba100a4f21cb7" +dependencies = [ + "der 0.8.2", + "pkcs5", + "rand_core 0.10.1", + "spki 0.8.0", ] [[package]] @@ -4830,13 +5165,40 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "primefield" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c555a6e4eb7d4e158fcb028c835c3b8642206ddc279b5c6b202ef9a8bdb592f4" +dependencies = [ + "crypto-bigint 0.7.5", + "crypto-common 0.2.2", + "ff 0.14.0", + "rand_core 0.10.1", + "subtle", + "zeroize", +] + [[package]] name = "primeorder" version = "0.13.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" dependencies = [ - "elliptic-curve", + "elliptic-curve 0.13.8", +] + +[[package]] +name = "primeorder" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c9f42978c78a00e3d68f69fc03e57a234debae69da4020a4fb588fcdcd07b06" +dependencies = [ + "elliptic-curve 0.14.1", + "once_cell", + "primefield", + "serdect", + "wnaf", ] [[package]] @@ -4848,6 +5210,15 @@ dependencies = [ "toml_edit 0.25.13+spec-1.1.0", ] +[[package]] +name = "proc-macro2" +version = "0.4.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf3d2011ab5c909338f7887f4fc896d35932e29146c12c8d01da6b22a80ba759" +dependencies = [ + "unicode-xid", +] + [[package]] name = "proc-macro2" version = "1.0.107" @@ -4894,8 +5265,8 @@ checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf" dependencies = [ "anyhow", "itertools 0.14.0", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -4926,8 +5297,8 @@ version = "48.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7e69fa1c4a555946f82e7894a7df88b0e9ee03b4266829b4811467c616ce51d" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -5034,13 +5405,22 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "quote" +version = "0.6.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce23b6b870e8f94f81fb0a363d65d86675884b34a09043c81e5562f11c1f8e1" +dependencies = [ + "proc-macro2 0.4.30", +] + [[package]] name = "quote" version = "1.0.47" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" dependencies = [ - "proc-macro2", + "proc-macro2 1.0.107", ] [[package]] @@ -5208,7 +5588,7 @@ version = "0.14.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "091e7a8e7d86e6feb87a27ce8e2cba29d49eff9507afeebefab7eeb2ca667fb4" dependencies = [ - "pem", + "pem 3.0.6", "ring", "rustls-pki-types", "time", @@ -5279,8 +5659,8 @@ version = "1.0.26" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2c9283685feec7d69af75fb0e858d5e7378f33fe4fc699383b2916ab9273e03c" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -5405,6 +5785,16 @@ dependencies = [ "subtle", ] +[[package]] +name = "rfc6979" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4a459cddafb3fe76b31fd8f1108007566c40301feb64dc7b54656eb7388172b" +dependencies = [ + "crypto-bigint 0.7.5", + "hmac 0.13.0", +] + [[package]] name = "rfd" version = "0.16.0" @@ -5620,6 +6010,37 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6518fc26bced4d53678a22d6e423e9d8716377def84545fe328236e3af070e7f" +[[package]] +name = "sad-rsa" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd7d4943477abb8580407b3e3af6bf2c8d6df55a1530c777743bf27ac55b2a04" +dependencies = [ + "const-oid 0.10.2", + "crypto-bigint 0.7.5", + "crypto-primes", + "digest 0.11.3", + "hmac 0.13.0", + "pkcs1", + "pkcs8 0.11.0", + "rand_core 0.10.1", + "sha1", + "sha2 0.11.0", + "signature 3.0.0", + "spki 0.8.0", + "zeroize", +] + +[[package]] +name = "salsa20" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f874456e72520ff1375a06c588eaf074b0f01f9e9e1aada45bd9b7954a6e42c" +dependencies = [ + "cfg-if", + "cipher", +] + [[package]] name = "same-file" version = "1.0.6" @@ -5674,16 +6095,42 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" +[[package]] +name = "scrypt" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d87af57419b594aa23fa95f09f0e06d80d84ba01c26148c43844cad6ff4485f0" +dependencies = [ + "cfg-if", + "pbkdf2", + "salsa20", + "sha2 0.11.0", +] + [[package]] name = "sec1" version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" dependencies = [ - "base16ct", - "der", + "base16ct 0.2.0", + "der 0.7.10", "generic-array", - "pkcs8", + "pkcs8 0.10.2", + "subtle", + "zeroize", +] + +[[package]] +name = "sec1" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d" +dependencies = [ + "base16ct 1.0.0", + "ctutils", + "der 0.8.2", + "hybrid-array", "subtle", "zeroize", ] @@ -5711,6 +6158,12 @@ dependencies = [ "libc", ] +[[package]] +name = "self_cell" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813" + [[package]] name = "semver" version = "1.0.28" @@ -5746,8 +6199,8 @@ version = "1.0.229" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -5801,8 +6254,8 @@ version = "0.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -5854,11 +6307,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660" dependencies = [ "darling", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] +[[package]] +name = "serdect" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66cf8fedced2fcf12406bcb34223dffb92eaf34908ede12fed414c82b7f00b3e" +dependencies = [ + "base16ct 1.0.0", + "serde", +] + [[package]] name = "serial_test" version = "4.0.1" @@ -5879,8 +6342,8 @@ version = "4.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a22144e767da4ddd8416dbf383700542ffd8a5dc493dfecedfe1fe3ad03c98ae" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -5975,7 +6438,7 @@ version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c1e303f8205714074f6068773f0e29527e0453937fe837c9717d066635b65f31" dependencies = [ - "pkcs8", + "pkcs8 0.10.2", "rand_core 0.6.4", "signature 2.2.0", "zeroize", @@ -5997,6 +6460,7 @@ version = "3.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5" dependencies = [ + "digest 0.11.3", "rand_core 0.10.1", ] @@ -6043,6 +6507,28 @@ dependencies = [ "serde", ] +[[package]] +name = "snafu" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d0bf93d08d6a44363b47d737f1f5bebbf5e6a1eaaa3d4c128ceeaca6b718292" +dependencies = [ + "backtrace", + "doc-comment", + "snafu-derive", +] + +[[package]] +name = "snafu-derive" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "624e94bd38e471f67883b467711e7a7ad7dbe284f5fb7e661dc8a671fc5b26a0" +dependencies = [ + "proc-macro2 0.4.30", + "quote 0.6.13", + "syn 0.15.44", +] + [[package]] name = "socket2" version = "0.6.5" @@ -6075,7 +6561,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" dependencies = [ "base64ct", - "der", + "der 0.7.10", +] + +[[package]] +name = "spki" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d9efca8738c78ee9484207732f728b1ef517bbb1833d6fc0879ca898a522f6f" +dependencies = [ + "base64ct", + "der 0.8.2", ] [[package]] @@ -6135,8 +6631,8 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bd2b84f2bc39a5705ef27ec785a11c934a41bbd4a24941e257927cddc26b60bf" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "sqlx-core", "sqlx-macros-core", "syn 2.0.119", @@ -6153,8 +6649,8 @@ dependencies = [ "either", "heck", "hex", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "serde", "serde_json", "sha2 0.10.9", @@ -6288,8 +6784,8 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2e1575d8d40908d70f6fd05537266b90ae71b15dbbe7a8b7dffa2b759306d329" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "structmeta-derive", "syn 2.0.119", ] @@ -6300,8 +6796,8 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "152a0b65a590ff6c3da95cabe2353ee04e6167c896b28e3b14478c2636c922fc" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6321,8 +6817,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664" dependencies = [ "heck", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6332,14 +6828,46 @@ version = "2.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" +[[package]] +name = "sxd-document-no-unsafe" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c08c6a37e27fb1559e036ae8f45672faf06623f13c74c8de9719d50536981f5" +dependencies = [ + "peresil", + "typed-arena", +] + +[[package]] +name = "sxd-xpath-no-unsafe" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0ff5bfe9c78786014d5a76d9328ea6508b0b74b7dc4a7c4d9b881ace23ce50d" +dependencies = [ + "peresil", + "snafu", + "sxd-document-no-unsafe", +] + +[[package]] +name = "syn" +version = "0.15.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ca4b3b69a77cbe1ffc9e198781b7acb0c7365a883670e8f1c1bc66fba79a5c5" +dependencies = [ + "proc-macro2 0.4.30", + "quote 0.6.13", + "unicode-xid", +] + [[package]] name = "syn" version = "2.0.119" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "unicode-ident", ] @@ -6349,8 +6877,8 @@ version = "3.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "unicode-ident", ] @@ -6369,8 +6897,8 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6466,8 +6994,8 @@ version = "1.0.69" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6477,8 +7005,8 @@ version = "2.0.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -6572,8 +7100,8 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6601,8 +7129,8 @@ version = "2.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 3.0.3", ] @@ -6864,8 +7392,8 @@ version = "0.1.31" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -6938,7 +7466,7 @@ version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ad06847b7afb65c7866a36664b75c40b895e318cea4f71299f013fb22965329d" dependencies = [ - "quote", + "quote 1.0.47", "syn 2.0.119", ] @@ -6958,6 +7486,12 @@ dependencies = [ "tokio", ] +[[package]] +name = "typed-arena" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a" + [[package]] name = "typed-path" version = "0.12.3" @@ -7038,6 +7572,12 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" +[[package]] +name = "unicode-xid" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" + [[package]] name = "unit-prefix" version = "0.5.2" @@ -7242,7 +7782,7 @@ version = "0.2.126" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "167ce5e579f6bcf889c4f7175a8a5a585de84e8ff93976ce393efa5f2837aab1" dependencies = [ - "quote", + "quote 1.0.47", "wasm-bindgen-macro-support", ] @@ -7253,8 +7793,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3997c7839262f4ef12cf90b818d6340c18e80f263f1a94bf157d0ec4420380e" dependencies = [ "bumpalo", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "wasm-bindgen-shared", ] @@ -7354,7 +7894,7 @@ version = "48.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1bd39f78fe9bc82cee4025ec9d52118269e9a1498016cc60119b14f2e1d86a8d" dependencies = [ - "addr2line", + "addr2line 0.26.1", "async-trait", "bitflags", "bumpalo", @@ -7365,7 +7905,7 @@ dependencies = [ "log", "mach2", "memfd", - "object", + "object 0.39.1", "once_cell", "postcard", "pulley-interpreter", @@ -7400,11 +7940,11 @@ dependencies = [ "cranelift-bforest", "cranelift-bitset", "cranelift-entity", - "gimli", + "gimli 0.33.0", "hashbrown 0.17.1", "indexmap 2.14.0", "log", - "object", + "object 0.39.1", "postcard", "rustc-demangle", "semver", @@ -7427,8 +7967,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f3d2b2f9f89a65bb2277d82fbdd49263d27d8233bc717d750c4b13a23d57721c" dependencies = [ "anyhow", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "wasmtime-internal-component-util", "wasmtime-internal-wit-bindgen", @@ -7463,10 +8003,10 @@ dependencies = [ "cranelift-entity", "cranelift-frontend", "cranelift-native", - "gimli", + "gimli 0.33.0", "itertools 0.14.0", "log", - "object", + "object 0.39.1", "pulley-interpreter", "smallvec", "target-lexicon", @@ -7521,7 +8061,7 @@ checksum = "a1fdea09d51e39c774984ca68a7d7486767e5b2935f5e686fa654aabcfc3c42d" dependencies = [ "cranelift-codegen", "log", - "object", + "object 0.39.1", "wasmtime-environ", ] @@ -7531,8 +8071,8 @@ version = "48.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "97e48a5f514c38c2f74249724cb3501e45548d3311ca9e3881694859fd6ba116" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -7649,9 +8189,9 @@ version = "0.31.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0" dependencies = [ - "proc-macro2", + "proc-macro2 1.0.107", "quick-xml", - "quote", + "quote 1.0.47", ] [[package]] @@ -7738,8 +8278,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed981675756e748a4725286a4059c9be006749a8db4120d54e2021d0f167bac3" dependencies = [ "heck", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "wasmtime-environ", "witx", @@ -7751,8 +8291,8 @@ version = "48.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f3927729af874585c58b85710128e40d459a7064bb9aea9b0b420fb5eafd555" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "wiggle-generate", ] @@ -7807,8 +8347,8 @@ version = "0.60.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -7818,8 +8358,8 @@ version = "0.59.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -8162,6 +8702,18 @@ dependencies = [ "wast 35.0.2", ] +[[package]] +name = "wnaf" +version = "0.14.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "795ca18b3fdb5e62bf982199278341ddcf7ebf7d32e25e212ad05d496e95f6fa" +dependencies = [ + "ff 0.14.0", + "group 0.14.0", + "hybrid-array", + "primefield", +] + [[package]] name = "writeable" version = "0.6.3" @@ -8175,11 +8727,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94" dependencies = [ "const-oid 0.9.6", - "der", - "spki", + "der 0.7.10", + "spki 0.7.3", "tls_codec", ] +[[package]] +name = "x509-cert" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "105ef4642d9cb137ef83d623d0e4bf08b8adf69e9918ca904a174adb6d3d038b" +dependencies = [ + "const-oid 0.10.2", + "der 0.8.2", + "spki 0.8.0", +] + [[package]] name = "x509-parser" version = "0.18.1" @@ -8198,6 +8761,15 @@ dependencies = [ "time", ] +[[package]] +name = "x520-stringprep" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9636764714ff558f8fce74e024f892ad39f5a5bdcba8e90a756a1d8d8491b4f7" +dependencies = [ + "unicode-normalization", +] + [[package]] name = "xattr" version = "1.6.1" @@ -8208,6 +8780,55 @@ dependencies = [ "rustix", ] +[[package]] +name = "xml-sec" +version = "0.1.16" +source = "git+https://github.com/odal-node/xml-sec.git?rev=7daf6028e08bc17f60ac36833d90c9307ca25449#7daf6028e08bc17f60ac36833d90c9307ca25449" +dependencies = [ + "aes", + "aes-gcm", + "aes-kw", + "base64 0.23.1", + "cbc", + "crypto-bigint 0.7.5", + "der 0.8.2", + "des", + "dsa", + "ed25519-dalek 3.0.0", + "getrandom 0.4.3", + "hmac 0.13.0", + "md-5", + "p256 0.14.0", + "p384", + "p521", + "pem 4.0.0", + "pkcs8 0.11.0", + "quick-xml", + "sad-rsa", + "self_cell", + "sha1", + "sha2 0.11.0", + "signature 3.0.0", + "subtle", + "sxd-document-no-unsafe", + "sxd-xpath-no-unsafe", + "thiserror 2.0.20", + "x509-cert 0.3.0", + "x509-parser", + "x520-stringprep", + "xmloxide", + "zeroize", +] + +[[package]] +name = "xmloxide" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "58666a3723753360aa92f2eda5c6f5392285c6d7f063b4c2b07f47c697a22b47" +dependencies = [ + "encoding_rs", +] + [[package]] name = "xmlparser" version = "0.13.6" @@ -8247,8 +8868,8 @@ version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "synstructure", ] @@ -8290,8 +8911,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fe96480bed92df2b442a1a30df364e12d08eed03aeb061f2b8dc6afb2be91119" dependencies = [ "proc-macro-crate", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "zbus_names", "zvariant", @@ -8324,8 +8945,8 @@ version = "0.8.56" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -8344,8 +8965,8 @@ version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "synstructure", ] @@ -8365,8 +8986,8 @@ version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -8398,8 +9019,8 @@ version = "0.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", ] @@ -8463,8 +9084,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "38a708216a18780796770bfe3f4739c7c83a3e8f789b755534bbbc06e4e23e12" dependencies = [ "proc-macro-crate", - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "syn 2.0.119", "zvariant_utils", ] @@ -8475,8 +9096,8 @@ version = "3.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90cb9383f9b45290407a1258b202d3f8f01db719eb60b4e4055c6375af4fc7c7" dependencies = [ - "proc-macro2", - "quote", + "proc-macro2 1.0.107", + "quote 1.0.47", "serde", "syn 2.0.119", "winnow 1.0.4", diff --git a/Cargo.toml b/Cargo.toml index 3af3f056..efed2edf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -195,3 +195,10 @@ wasmtime-wasi = "48" # GS1 / JSON-LD json-ld = "0.21" + +# Vendored one-constant fix: the published crate hard-caps XML node-sets at +# 65536 and the Italian and French trusted lists carry 65540 and 65541, so +# neither verifies. Reported upstream as structured-world/xml-sec#158 — remove +# this stanza and the fork when that ships. +[patch.crates-io] +xml-sec = { git = "https://github.com/odal-node/xml-sec.git", rev = "7daf6028e08bc17f60ac36833d90c9307ca25449" } diff --git a/crates/dpp-seal/Cargo.toml b/crates/dpp-seal/Cargo.toml index 32874031..73e94193 100644 --- a/crates/dpp-seal/Cargo.toml +++ b/crates/dpp-seal/Cargo.toml @@ -54,6 +54,11 @@ zeroize = { workspace = true } # attack does not apply. roxmltree = "0.20" +# XMLDSig verification for trusted lists. Pure Rust, so the node stays a single +# self-hosted binary — the constraint that ruled out libxmlsec1 bindings and the +# EU DSS validator. See the workspace `[patch.crates-io]` for the vendored fix. +xml-sec = "0.1.16" + cms = { version = "0.2", default-features = false } x509-cert = "0.2" der = "0.7" diff --git a/crates/dpp-seal/src/trustlist/anchor.rs b/crates/dpp-seal/src/trustlist/anchor.rs index 8c757008..55bbbe82 100644 --- a/crates/dpp-seal/src/trustlist/anchor.rs +++ b/crates/dpp-seal/src/trustlist/anchor.rs @@ -27,7 +27,7 @@ use sha2::{Digest as _, Sha256}; /// claim of qualified status that rests on one. Configuration is for choices /// about a deployment; this is the thing the deployment is trusted *against*. /// -/// It is the same reasoning [`crate::config`] applies to `SEAL_PROVIDER` — a +/// It is the same reasoning [`crate::config::SEAL_PROVIDER`] applies — a /// node that cannot name its trust provider must not quietly become one that has /// none — carried to its root. Changing the anchor is a reviewed commit and a /// release, and that is the feature, not the friction. @@ -73,7 +73,7 @@ pub struct LotlAnchor { /// /// The early signal is in the LOTL itself: the first entry of its /// `SchemeInformationURI` is the notice currently in force, so a node can notice -/// that [`Self::notice_uri`] no longer matches and say so *before* the +/// that [`LotlAnchor::notice_uri`] no longer matches and say so *before* the /// certificates change under it. /// /// To refresh: open the notice, take the SHA-256 **base64** digests from the diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index a09bcefd..a581ea69 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -7,71 +7,52 @@ //! a vendor. The vocabulary those lists are written in lives in //! [`dpp_domain::trusted_list`]; this module fetches and parses the documents. //! -//! # 🚩 Nothing here is verified, and the ceiling that puts on it -//! -//! A trusted list is an **XAdES-signed** XML document. The signature, checked -//! against the scheme operator's certificate, is what makes it evidence rather -//! than a file from a web server. **This module does not check it.** -//! -//! Verifying one needs XML Signature over the **canonicalised** subtree, which -//! is where subtle signature-verification bugs live: a canonicaliser that -//! differs from the signer's in any edge case either rejects valid documents or, -//! worse, accepts one whose signed portion is not what the verifier thinks it -//! is. -//! -//! Rust has candidates rather than a settled answer — `xml-sec` is a young -//! pure-Rust implementation, `xml_c14n` binds libxml2 for the canonicalisation -//! half, and the EU's own reference validator is a Java application. Choosing -//! between them is a real decision with a deployment cost attached, not a -//! dependency to add in passing, so it is not made here. The gap is named rather -//! than glossed. -//! -//! ## For whoever implements it -//! -//! `xml-sec` has been evaluated against the real corpus and **verifies every -//! reachable EU trusted list**, rejecting single-byte tampering in signed -//! content and inside the XAdES `SignedProperties` alike. Two national lists -//! (Italy, France) exceed a hard-coded node-set ceiling in the published crate; -//! a fork carrying the one-constant fix is pinned and ready: -//! -//! ```toml -//! # workspace Cargo.toml — remove once the upstream fix ships -//! [patch.crates-io] -//! xml-sec = { git = "https://github.com/odal-node/xml-sec.git", rev = "7daf6028e08bc17f60ac36833d90c9307ca25449" } -//! ``` -//! -//! It is deliberately **not** wired in yet: a patch for a crate nothing depends -//! on is a build warning. -//! -//! The other half — knowing *which* key to trust — is done. [`EU_LOTL_ANCHOR`] -//! pins the certificates the Official Journal authorises to sign the list of -//! lists, so a verifier has something to check the signing certificate against -//! rather than trusting whichever one the document happens to carry. Read -//! [`LotlAnchor::authorises`] before using it: it is a precondition, never a -//! verdict. -//! -//! What remains is to run the two together — establish the certificate is -//! anchored, then verify the signature with it, then verify each national list -//! against the certificates the now-verified LOTL names for that territory. -//! -//! What follows from that is a hard boundary, and it is built into the type -//! names: [`UnverifiedTrustedList`] is what parsing produces, and nothing in -//! this crate turns it into a verdict. -//! -//! **Sound uses.** Answering *"which service types is this provider listed -//! under, and with what status?"* — for a trust report, or to put a precise -//! question to a provider and its supervisory body. For the Art. 39a check -//! ([`TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT`](dpp_domain::trusted_list::TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT)) -//! there is no other automated starting point. -//! -//! **Unsound uses.** Any compliance verdict. In particular this must not be used -//! to produce [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation), -//! which asserts the legs of Art. 32(1) were checked. An unverified document -//! cannot establish that a certificate was qualified; it can only report what -//! something claimed. -//! -//! This is the same discipline [`crate::cades`] applies to a seal's own bytes: -//! read, report, and never imply a check that did not happen. +//! # What is verified, and what is not +//! +//! A trusted list is an **XAdES-signed** XML document, and that signature is +//! what makes it evidence rather than a file from a web server. The two kinds of +//! document here are at different stages: +//! +//! - **The list of lists is verified.** [`verify_lotl`] checks that the +//! certificate in its `ds:KeyInfo` is one the Official Journal authorises +//! ([`EU_LOTL_ANCHOR`]) and that the XML signature verifies with it. Success +//! yields a [`VerifiedLotl`], which has no public constructor — holding one is +//! evidence the check ran. +//! - **National lists are not.** [`parse_trusted_list`] yields an +//! [`UnverifiedTrustedList`], and the name is the warning. Their signing +//! certificates are named by the LOTL per territory, so verifying them is the +//! next step and reuses the same machinery. +//! +//! So a national list is still *what a server answered*, not *what a Member +//! State published*. That is sound for reading — answering "which service types +//! is this provider listed under, and with what status?", which is the only +//! automated starting point for the Art. 39a check +//! ([`TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT`](dpp_domain::trusted_list::TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT)). +//! It is **not** sound for a compliance verdict, and in particular must not +//! produce [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation), +//! which asserts the legs of Art. 32(1) were checked. +//! +//! Same discipline [`crate::cades`] applies to a seal's own bytes: read, report, +//! and never imply a check that did not happen. +//! +//! ## The canonicalisation problem, and the vendored fix +//! +//! XML Signature verifies a digest over the **canonicalised** subtree, not over +//! the bytes as received, and that is where signature bugs live: a canonicaliser +//! that differs from the signer's in any edge case either rejects valid +//! documents or — worse — accepts one whose signed portion is not what the +//! verifier believes. +//! +//! `xml-sec` does it in pure Rust, which is what keeps this node a single +//! self-hosted binary; the alternatives were libxmlsec1 bindings or the EU's +//! Java validator, each of which would put a native library or a JVM into every +//! operator's deployment. +//! +//! The published crate hard-caps XML node-sets at 65 536 and the Italian and +//! French lists carry 65 540 and 65 541, so neither verifies. The workspace +//! therefore pins a fork carrying that one constant, and the exit condition is +//! in the manifest beside it: remove the `[patch.crates-io]` stanza once +//! `structured-world/xml-sec#158` ships. //! //! # Time, not the present //! @@ -90,6 +71,9 @@ mod model; mod parse; #[cfg(test)] mod tests; +mod verify; +#[cfg(test)] +mod verify_tests; pub use anchor::{EU_LOTL_ANCHOR, LotlAnchor}; pub use fetch::{ @@ -97,3 +81,4 @@ pub use fetch::{ }; pub use model::{ListedProvider, ListedService, TrustedListPointer, UnverifiedTrustedList}; pub use parse::{parse_lotl, parse_trusted_list}; +pub use verify::{LotlRejected, VerifiedLotl, verify_lotl, verify_lotl_with}; diff --git a/crates/dpp-seal/src/trustlist/verify.rs b/crates/dpp-seal/src/trustlist/verify.rs new file mode 100644 index 00000000..5c80ecad --- /dev/null +++ b/crates/dpp-seal/src/trustlist/verify.rs @@ -0,0 +1,206 @@ +//! Verifying the list of trusted lists against the pinned anchor. + +use base64::Engine as _; +use roxmltree::Document; +use xml_sec::xmldsig::{DefaultKeyResolver, DsigStatus, VerifyContext}; + +use super::anchor::{EU_LOTL_ANCHOR, LotlAnchor}; +use super::model::TrustedListPointer; +use super::parse::parse_lotl; + +/// Why a list of trusted lists was not accepted. +/// +/// Typed rather than a string, because the operator's response differs +/// completely per case and a log line has to make that obvious. A rejected LOTL +/// is either a stale pin, an attack, or a broken download, and those want three +/// different people. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum LotlRejected { + /// The document could not be read as XML, or is not a trusted list. + Malformed(String), + /// It carries no signature, or none this verifier could locate. + NotSigned, + /// The signature carries no X.509 certificate to check against. + NoCertificate, + /// The certificate is not one the Official Journal authorises. + /// + /// **The interesting case.** Most often it means the pin is stale — the + /// Commission has published a new notice and the anchor has not been + /// refreshed. It can also mean the document is not the Commission's at all. + /// The two are indistinguishable from here, which is why the digest is + /// carried: an operator can compare it against the notice themselves. + NotAnchored { + /// Base64 SHA-256 of the certificate that was offered. + offered: String, + /// CELEX of the notice this node is pinned to. + pinned_notice: &'static str, + }, + /// The certificate is authorised, and the signature over the document does + /// not verify with it. + /// + /// Not a stale pin. The document has been altered, truncated, or was never + /// signed by the key it names. + SignatureInvalid(String), +} + +impl std::fmt::Display for LotlRejected { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Malformed(why) => write!(f, "not a readable trusted list: {why}"), + Self::NotSigned => f.write_str("the document carries no signature"), + Self::NoCertificate => f.write_str("the signature carries no certificate"), + Self::NotAnchored { + offered, + pinned_notice, + } => write!( + f, + "signed by {offered}, which Official Journal notice {pinned_notice} does not \ + authorise — refresh the pinned anchor from the current notice, or treat this \ + document as untrusted" + ), + Self::SignatureInvalid(why) => { + write!(f, "the signature does not verify: {why}") + } + } + } +} + +impl std::error::Error for LotlRejected {} + +/// A list of trusted lists whose signature has been verified against the anchor. +/// +/// The type exists so a verified document cannot be passed where an unverified +/// one is expected, or the reverse. [`UnverifiedTrustedList`](super::UnverifiedTrustedList) +/// is what parsing alone produces; this is what survives +/// [`verify_lotl`]. +/// +/// Constructible only by this module — there is no public constructor, so a +/// value of this type is evidence that the check ran. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VerifiedLotl { + pointers: Vec, + signed_by: String, +} + +impl VerifiedLotl { + /// Every pointer the verified document carries. + #[must_use] + pub fn pointers(&self) -> &[TrustedListPointer] { + &self.pointers + } + + /// Base64 SHA-256 of the anchored certificate that signed it. + /// + /// For a trust report: it says *which* of the authorised certificates the + /// Commission is currently signing with, which is the thing that changes + /// when a rotation is coming. + #[must_use] + pub fn signed_by(&self) -> &str { + &self.signed_by + } +} + +/// Verify the list of trusted lists against the compiled-in anchor. +/// +/// # What a success means +/// +/// Two things, both necessary and neither sufficient alone: +/// +/// 1. the certificate in the document's `ds:KeyInfo` is one the Official Journal +/// authorises to sign the LOTL — see [`LotlAnchor::authorises`]; **and** +/// 2. the XML signature over the canonicalised document verifies with that +/// certificate. +/// +/// The anchor is what makes the signature check mean anything. A forgery signed +/// by its author's own key verifies perfectly against that key; only (1) rules +/// it out, and a verifier that did (2) alone would accept anything self-consistent. +/// +/// The two are checked in that order for a narrower reason: signature +/// verification canonicalises the whole document, which is real work on input +/// that has not yet been shown to come from anywhere in particular. Establishing +/// the key is authorised first keeps that work behind the trust decision. The +/// verdict would be the same either way — this is defence in depth, not +/// correctness. +/// +/// # What it still does not mean +/// +/// That the certificate is *currently valid*. This checks identity against a +/// published list, not expiry or revocation — the Official Journal is the +/// authority for which keys may sign, and it is not a CRL. A node should report +/// the certificate's validity window separately; the one signing when this +/// anchor was pinned expires 2027-11-17. +/// +/// # Errors +/// +/// [`LotlRejected`], typed so the three very different causes — stale pin, +/// tampered document, broken download — are distinguishable at the call site. +pub fn verify_lotl(xml: &str) -> Result { + verify_lotl_with(xml, &EU_LOTL_ANCHOR) +} + +/// [`verify_lotl`] against a caller-supplied anchor. +/// +/// Exists for this crate's tests, which need to exercise the `NotAnchored` path +/// without a forged Commission signature. Production callers want +/// [`verify_lotl`]: an anchor that arrives as an argument is an anchor something +/// else chose, and the whole point of pinning is that nothing else chooses it. +pub fn verify_lotl_with(xml: &str, anchor: &LotlAnchor) -> Result { + let certificate = signing_certificate(xml)?; + let der = base64::engine::general_purpose::STANDARD + .decode(&certificate) + .map_err(|e| LotlRejected::Malformed(format!("certificate is not base64: {e}")))?; + + // The anchor before the signature: canonicalising a document is real work, + // and this keeps it behind the trust decision. The verdict is the same + // either way — see this function's documentation. + if !anchor.authorises(&der) { + return Err(LotlRejected::NotAnchored { + offered: base64::engine::general_purpose::STANDARD + .encode(::digest(&der)), + pinned_notice: anchor.notice_celex(), + }); + } + + let resolver = DefaultKeyResolver::default(); + let outcome = VerifyContext::new() + .key_resolver(&resolver) + .verify(xml) + .map_err(|e| LotlRejected::SignatureInvalid(e.to_string()))?; + + if !matches!(outcome.status, DsigStatus::Valid) { + return Err(LotlRejected::SignatureInvalid(format!( + "{:?}", + outcome.status + ))); + } + + let pointers = parse_lotl(xml).map_err(|e| LotlRejected::Malformed(e.to_string()))?; + + Ok(VerifiedLotl { + pointers, + signed_by: base64::engine::general_purpose::STANDARD + .encode(::digest(&der)), + }) +} + +/// The base64 certificate from the document's signature. +/// +/// Read with the same local-name matching the rest of this module uses: the +/// signature is in the `ds:` namespace by convention rather than by requirement, +/// and a publisher is free to bind a different prefix. +fn signing_certificate(xml: &str) -> Result { + let doc = Document::parse(xml).map_err(|e| LotlRejected::Malformed(format!("not XML: {e}")))?; + + let signature = doc + .descendants() + .find(|n| n.is_element() && n.tag_name().name() == "Signature") + .ok_or(LotlRejected::NotSigned)?; + + signature + .descendants() + .find(|n| n.is_element() && n.tag_name().name() == "X509Certificate") + .and_then(|n| n.text()) + .map(|t| t.split_whitespace().collect::()) + .filter(|s| !s.is_empty()) + .ok_or(LotlRejected::NoCertificate) +} diff --git a/crates/dpp-seal/src/trustlist/verify_tests.rs b/crates/dpp-seal/src/trustlist/verify_tests.rs new file mode 100644 index 00000000..22853b8f --- /dev/null +++ b/crates/dpp-seal/src/trustlist/verify_tests.rs @@ -0,0 +1,135 @@ +//! Verifying the real list of trusted lists against the real anchor. + +use super::verify::{LotlRejected, verify_lotl}; + +/// The EU list of trusted lists, as published. +/// +/// The real document. It will go stale as the Commission republishes, and that +/// is fine: a signature does not expire when a newer document appears, so an +/// archived LOTL keeps verifying. Every assertion here is about *verification*, +/// never about which providers happen to be listed today. +const EU_LOTL: &str = include_str!("../../tests/fixtures/eu-lotl.xml"); + +/// The published list of trusted lists verifies against the pinned anchor. +/// +/// The end-to-end claim of this module: a document fetched from the Commission, +/// signed by a certificate the Official Journal authorises, over exclusive-C14N +/// canonicalised XML with RSA-SHA512 — and both halves check out. +#[test] +fn the_published_lotl_verifies() { + let verified = verify_lotl(EU_LOTL).expect("the published LOTL verifies"); + + assert!( + !verified.pointers().is_empty(), + "and it carries the pointers to the national lists" + ); + assert_eq!( + verified.signed_by(), + "4KYg+7Z0c2K7kzrEQWnWdqVTREcWz18xYF8SoiuDlrE=", + "signed by the second certificate the notice authorises" + ); +} + +/// A single altered byte is rejected. +/// +/// Tampering applied at **equal length**, so nothing but the intended bytes +/// changes — a size change would be a second variable and the rejection could be +/// for the wrong reason. +/// +/// The target is a trusted list's location. That is the attack worth pinning: a +/// LOTL that points a relying party at an attacker's national list would poison +/// every qualified-status answer downstream, and it is a change of a few +/// characters in a URL. +#[test] +fn a_redirected_pointer_is_rejected() { + let from = "https://ec.europa.eu/tools/lotl/eu-lotl-pivot-378.xml"; + let to = "https://ec.eur0pa.eu/tools/lotl/eu-lotl-pivot-378.xml"; + assert_eq!(from.len(), to.len(), "the tamper must not change length"); + + let at = EU_LOTL + .find(from) + .expect("the fixture carries that pointer"); + let mut tampered = String::with_capacity(EU_LOTL.len()); + tampered.push_str(&EU_LOTL[..at]); + tampered.push_str(to); + tampered.push_str(&EU_LOTL[at + from.len()..]); + + match verify_lotl(&tampered) { + Err(LotlRejected::SignatureInvalid(_)) => {} + other => panic!("a redirected pointer must be rejected, got {other:?}"), + } +} + +/// A document signed by an unanchored key is rejected before its signature is +/// even considered. +/// +/// The Finnish trusted list is genuine, correctly signed, and signed by +/// **Finland's** scheme operator — which the Official Journal does not authorise +/// to sign the *list of lists*. So it must be refused, and refused as +/// `NotAnchored` rather than as a bad signature: the signature is perfectly +/// good, and reporting it as invalid would send an operator hunting a tampered +/// document that does not exist. +/// +/// It is also what the anchor is *for*. Drop the anchor check and this document +/// verifies cleanly, because it really is properly signed — by the wrong +/// authority. The signature alone cannot tell those apart. +#[test] +fn a_genuine_document_signed_by_the_wrong_authority_is_not_anchored() { + let finnish = include_str!("../../tests/fixtures/fi-trusted-list.xml"); + + match verify_lotl(finnish) { + Err(LotlRejected::NotAnchored { + offered, + pinned_notice, + }) => { + assert!(!offered.is_empty(), "the offered digest is reported"); + assert_eq!(pinned_notice, "52026XC01944"); + } + other => panic!("Finland does not sign the list of lists, got {other:?}"), + } +} + +/// Each malformed shape is told apart, because the operator response differs. +#[test] +fn the_rejection_says_which_kind_of_wrong() { + assert!(matches!( + verify_lotl("not xml"), + Err(LotlRejected::Malformed(_)) + )); + + let unsigned = r#" + + EU +"#; + assert!(matches!( + verify_lotl(unsigned), + Err(LotlRejected::NotSigned) + )); + + let no_cert = r#" + + +"#; + assert!(matches!( + verify_lotl(no_cert), + Err(LotlRejected::NoCertificate) + )); +} + +/// A rejection reads as an instruction, not a code. +/// +/// `NotAnchored` is the one an operator will actually meet, most often because +/// the pin went stale rather than because anyone attacked them. The message has +/// to say that, and name the notice to compare against. +#[test] +fn the_not_anchored_message_tells_an_operator_what_to_do() { + let rendered = LotlRejected::NotAnchored { + offered: "AAAA".to_owned(), + pinned_notice: "52026XC01944", + } + .to_string(); + + assert!(rendered.contains("52026XC01944"), "names the pinned notice"); + assert!(rendered.contains("refresh"), "says what to do: {rendered}"); + assert!(rendered.contains("AAAA"), "and what was offered"); +} diff --git a/crates/dpp-seal/tests/fixtures/eu-lotl.xml b/crates/dpp-seal/tests/fixtures/eu-lotl.xml new file mode 100644 index 00000000..ba175915 --- /dev/null +++ b/crates/dpp-seal/tests/fixtures/eu-lotl.xml @@ -0,0 +1,2176 @@ + + + 6 + 393 + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUlistofthelists + + European Commission + Европейска комисия + Comisión Europea + Evropská komise + Europa-Kommissionen + Europäische Kommission + Euroopa Komisjon + Ευρωπαϊκή Επιτροπή + Commission européenne + Commissione europea + Eiropas Komisija + Europos Komisija + Európai Bizottság + Il-Kummissjoni Ewropea + Europese Commissie + Komisja Europejska + Comissão Europeia + Comisia Europeană + Európska komisia + Evropska komisija + Euroopan komissio + Europeiska kommissionen + Europska komisija + + + + + Rue de la Loi 200 + Bruxelles + 1049 + BE + + + Wetstraat 200 + Brussel + 1049 + BE + + + Rue de la Loi/Wetstraat 200 + Brussels + 1049 + BE + + + + mailto:EC-TL-Service@ec.europa.eu + https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists + + + + EU:List containing the information notified by Member States pursuant to Article 4(1) and Article 4(2) of Commission Implementing Decision (EU) 2015/1505 of 8 September 2015 laying down technical specifications and formats relating to trusted lists pursuant to Article 22(5) of Regulation (EU) No 910/2014 of the European Parliament and of the Council on electronic identification and trust services for electronic transactions in the internal market, published by the Commission in accordance with Article 4(3) of Commission Implementing Decision (EU) 2015/1505. + EU:Списък, съдържащ в съответствие с член 2, параграф 4 от Решение 2009/767/ЕО на Комисията от 16 октомври 2009 г. за определяне на мерки, улесняващи прилагането на процедури с помощта на електронни средства чрез единични звена за контакт в съответствие с Директива 2006/123/ЕО на Европейския парламент и на Съвета относно услугите на вътрешния пазар, изменено с Решение 2010/425/ЕС на Комисията и Решение 2013/662/ЕС за изпълнение на Комисията, информацията, съобщена от държавите членки съгласно член 2, параграф 3 от Решение 2009/767/ЕО на Комисията. + EU:De conformidad con el artículo 2, apartado 4, de la Decisión 2009/767/CE de la Comisión, de 16 de octubre de 2009, por la que se adoptan medidas que facilitan el uso de procedimientos por vía electrónica a través de las «ventanillas únicas» con arreglo a la Directiva 2006/123/CE del Parlamento Europeo y del Consejo relativa a los servicios en el mercado interior, modificada por la Decisión 2010/425/UE de la Comisión y por la Decisión de Ejecución 2013/662/UE de la Comisión, la presente lista contiene la información proporcionada por los Estados miembros según lo previsto en el artículo 2, apartado 3, de la Decisión 2009/767/CE de la Comisión. + EU:Seznam zveřejněný podle čl. 2 odst. 4 rozhodnutí Komise 2009/767/ES ze dne 16. října 2009, kterým se stanovují opatření pro usnadnění užití postupů s využitím elektronických prostředků prostřednictvím „jednotných kontaktních míst“ podle směrnice Evropského parlamentu a Rady 2006/123/ES o službách na vnitřním trhu, ve znění rozhodnutí Komise 2010/425/EU a prováděcího rozhodnutí Komise 2013/662/EU, který obsahuje informace oznámené členskými státy v souladu s čl. 2 odst. 3 rozhodnutí Komise 2009/767/ES. + EU:Listen indeholder, jf. artikel 2, stk. 4, i Kommissionens beslutning 2009/767/EF af 16. oktober 2009 om fastlæggelse af foranstaltninger, der skal lette anvendelsen af elektroniske procedurer ved hjælp af "kvikskranker" i henhold til Europa-Parlamentets og Rådets direktiv 2006/123/EF om tjenesteydelser i det indre marked, som ændret ved Kommissionens afgørelse 2010/425/EU og Kommissionens gennemførelsesafgørelse 2013/662/EU, de oplysninger, der indgives af medlemsstaterne i henhold til artikel 2, stk. 3, i Kommissionens beslutning 2009/767/EF. + EU:Liste, die in Übereinstimmung mit Artikel 2 Absatz 4 der Entscheidung 2009/767/EG der Kommission vom 16. Oktober 2009 über Maßnahmen zur Erleichterung der Nutzung elektronischer Verfahren über „einheitliche Ansprechpartner“ gemäß der Richtlinie 2006/123/EG des Europäischen Parlaments und des Rates über Dienstleistungen im Binnenmarkt – geändert durch den Beschluss 2010/425/EU der Kommission und den Durchführungsbeschluss 2013/662/EU der Kommission – die von den Mitgliedstaaten gemäß Artikel 2 Absatz 3 der Entscheidung 2009/767/EG der Kommission übermittelten Informationen enthält: + EU:Nimekiri kooskõlas komisjoni 16. oktoobri 2009. aasta otsuse 2009/767/EÜ (millega kehtestatakse meetmed elektrooniliste haldustoimingute kasutamise lihtsustamiseks ühtsete kontaktpunktide kaudu, mis on sätestatud Euroopa Parlamendi ja nõukogu direktiivis 2006/123/EÜ teenuste kohta siseturul; muudetud komisjoni otsusega 2010/425/EL ja komisjoni rakendusotsusega 2013/662/EL) artikli 2 lõikega 4; nimekirjas esitatakse teave, mille liikmesriigid on edastanud komisjoni otsuse 2009/767/EÜ artikli 2 lõike 3 kohaselt. + EU:Ο παρών κατάλογος περιέχει - σύμφωνα με το άρθρο 2 παράγραφος 4 της απόφασης 2009/767/ΕΚ της Επιτροπής, της 16ης Οκτωβρίου 2009, σχετικά με τη θέσπιση μέτρων που διευκολύνουν τη χρήση διαδικασιών με ηλεκτρονικά μέσα μέσω των ενιαίων κέντρων εξυπηρέτησης βάσει της οδηγίας 2006/123/ΕΚ του Ευρωπαϊκού Κοινοβουλίου και του Συμβουλίου σχετικά με τις υπηρεσίες στην εσωτερική αγορά, όπως τροποποιήθηκε με την απόφαση 2010/425/ΕΕ της Επιτροπής και την εκτελεστική απόφαση 2013/662/ΕΕ της Επιτροπής - τις πληροφορίες που κοινοποιούνται από τα κράτη μέλη σύμφωνα με το άρθρο 2 παράγραφος 3 της απόφασης 2009/767/ΕΚ της Επιτροπής. + EU:Liste contenant, par application de l’article 2, paragraphe 4, de la décision 2009/767/CE de la Commission du 16 octobre 2009 établissant des mesures destinées à faciliter l’exécution de procédures par voie électronique par l’intermédiaire des «guichets uniques» conformément à la directive 2006/123/CE du Parlement européen et du Conseil relative aux services dans le marché intérieur, telle que modifiée par la décision 2010/425/UE de la Commission et la décision d'exécution 2013/662/UE de la Commission, les informations communiquées par les États membres en application de l'article 2, paragraphe 3, de la décision 2009/767/CE de la Commission. + EU:Conformemente all'articolo 2, paragrafo 4, della decisione 2009/767/CE della Commissione, del 16 ottobre 2009, che stabilisce misure per facilitare l'uso di procedure per via elettronica mediante gli "sportelli unici" di cui alla direttiva 2006/123/CE del Parlamento europeo e del Consiglio relativa ai servizi nel mercato interno, modificata dalla decisione 2010/425/UE della Commissione e dalla decisione di esecuzione 2013/662/UE della Commissione, il presente elenco UE contiene le informazioni comunicate dagli Stati membri a norma dell'articolo 2, paragrafo 3, della decisione 2009/767/CE. + EU:Saraksts, kas saskaņā ar 2. panta 4. punktu Komisijas 2009. gada 16. oktobra Lēmumā 2009/767/EK par pasākumiem, lai veicinātu procedūru veikšanu elektroniski, izmantojot vienotos kontaktpunktus atbilstoši Eiropas Parlamenta un Direktīva 2006/123/EK par pakalpojumiem iekšējā tirgū, kurā grozījumi izdarīti ar Komisijas Lēmumu 2010/425/ES un Komisijas Īstenošanas Lēmumu 2013/662/ES, ietver informāciju, ko dalībvalstis paziņojušas saskaņā ar Komisijas Lēmuma 2009/767/EK 2. panta 3. punktu. + EU:Sąrašas, kuriame pagal 2009 m. spalio 16 d. Komisijos sprendimo 2009/767/EB, kuriuo pagal Europos Parlamento ir Tarybos direktyvą 2006/123/EB dėl paslaugų vidaus rinkoje nustatomos priemonės procedūroms, atliekamoms naudojantis elektroninėmis priemonėmis ir kontaktinių centrų paslaugomis, palengvinti, su pakeitimais, padarytais Komisijos sprendimu 2010/425/ES ir Komisijos įgyvendinimo sprendimu 2013/662/ES, 2 straipsnio 4 dalį pateikiama informacija, kurią valstybės narės pateikė pagal Komisijos sprendimo 2009/767/EB 2 straipsnio 3 dalį. + EU:Jegyzék, amely az eljárásoknak a belső piaci szolgáltatásokról szóló 2006/123/EK európai parlamenti és tanácsi irányelv szerinti egyablakos ügyintézési pontokon keresztül elektronikus eszközökkel történő teljesítését lehetővé tevő rendelkezések meghatározásáról szóló, a 2010/425/EU bizottsági határozattal és a 2013/662/EU bizottsági végrehajtási határozattal módosított, 2009. október 16-i 2009/767/EK bizottsági határozat 2. cikkének (4) bekezdésével összhangban tartalmazza a tagállamok által a 2009/767/EK bizottsági határozat 2. cikke (3) bekezdésének megfelelően bejelentett információkat. + EU:Lista li fiha, skont l-Artikolu 2(4) tad-Deċiżjoni tal-Kummissjoni 2009/767/KE tas-16 ta’ Ottubru 2009 li tistipula miżuri li jiffaċilitaw l-użu ta’ proċeduri b’mezzi elettroniċi permezz tal-punti ta’ kuntatt waħdieni skont id-Direttiva 2006/123/KE tal-Parlament Ewropew u tal-Kunsill dwar is-servizzi fis-suq intern, kif emendata mid-Deċiżjoni tal-Kummissjoni 2010/425/UE u mid-Deċiżjoni ta' Implimentazzjoni tal-Kummissjoni 2013/662/UE, l-informazzjoni notifikata mill-Istati Membri skont l-Artikolu 2(3) tad-Deċiżjoni tal-Kummissjoni 2009/767/KE. + EU:Lijst waarin overeenkomstig artikel 2, lid 4, van Beschikking 2009/767/EG van de Commissie van 16 oktober 2009 inzake maatregelen voor een gemakkelijker gebruik van elektronische procedures via het „één- loket” in het kader van Richtlijn 2006/123/EG van het Europees Parlement en de Raad betreffende diensten op de interne markt, zoals gewijzigd bij Besluit 2010/425/EU van de Commissie en Uitvoeringsbesluit 2013/662/EU van de Commissie, de informatie is opgenomen die door de lidstaten overeenkomstig artikel 2, lid 3, van Beschikking 2009/767/EG van de Commissie is medegedeeld. + EU:Wykaz zawierający, zgodnie z art. 2 ust. 4 decyzji Komisji 2009/767/WE z dnia 16 października 2009 r. ustanawiającej środki ułatwiające korzystanie z procedur realizowanych drogą elektroniczną poprzez „pojedyncze punkty kontaktowe” zgodnie z dyrektywą 2006/123/WE Parlamentu Europejskiego i Rady dotyczącą usług na rynku wewnętrznym, zmienioną decyzją Komisji 2010/425/UE i decyzją wykonawczą Komisji 2013/662/UE, informacje przekazane przez państwa członkowskie zgodnie z art. 2 ust. 3 decyzji Komisji 2009/767/WE. + EU:Lista contendo, em conformidade com o artigo 2.º, n.º 4, da Decisão 2009/767/CE da Comissão, de 16 de outubro de 2009, que determina medidas destinadas a facilitar a utilização de procedimentos informatizados através de «balcões únicos», nos termos da Diretiva 2006/123/CE do Parlamento Europeu e do Conselho relativa aos serviços no mercado interno, com a redação que lhe foi dada pela Decisão 2010/425/UE da Comissão e pela Decisão de Execução 2013/662/UE da Comissão, as informações notificadas pelos Estados-Membros nos termos do artigo 2.º, n.º 3, da Decisão 2009/767/CE da Comissão. + EU:Listă care conține, în conformitate cu articolul 2 alineatul (4) din Decizia 2009/767/CE a Comisiei din 16 octombrie 2009 de stabilire a unor măsuri de facilitare a utilizării procedurilor prin mijloace electronice prin intermediul „ghișeelor unice” în temeiul Directivei 2006/123/CE a Parlamentului European și a Consiliului privind serviciile în cadrul pieței interne, astfel cum a fost modificată prin Decizia 2010/425/UE a Comisiei și Decizia de punere în aplicare 2013/662/UE a Comisiei, informațiile notificate de statele membre în temeiul articolului 2 alineatul (3) din Decizia 2009/767/CE a Comisiei. + EU:Zoznam, ktorý obsahuje v súlade s článkom 2 ods. 4 rozhodnutia Komisie 2009/767/ES zo 16. októbra 2009, ktorým sa ustanovujú opatrenia na uľahčenie postupov elektronickými spôsobmi prostredníctvom „miest jednotného kontaktu“ podľa smernice Európskeho parlamentu a Rady 2006/123/ES o službách na vnútornom trhu, zmeneného rozhodnutím Komisie 2010/425/EÚ a vykonávacím rozhodnutím Komisie 2013/662/EÚ, informácie oznámené členskými štátmi podľa článku 2 ods. 3 rozhodnutia Komisie 2009/767/ES. + EU:Seznam, ki v skladu s členom 2(4) Odločbe Komisije 2009/767/ES z dne 16. oktobra 2009 o vzpostavitvi ukrepov za pospeševanje uporabe postopkov po elektronski poti s pomočjo enotnih kontaktnih točk po Direktivi 2006/123/ES Evropskega parlamenta in Sveta o storitvah na notranjem trgu, kakor je bila spremenjena s Sklepom Komisije 2010/425/EU in Izvedbenim sklepom Komisije 2013/662/EU, vsebuje informacije, ki jih države članice sporočijo v skladu s členom 2(3) Odločbe Komisije 2009/767/ES. + EU:Luettelo, joka sisältää toimenpiteistä sähköisten menettelyjen käytön edistämiseksi keskitettyjä asiointipisteitä käyttäen palveluista sisämarkkinoilla annetun Euroopan parlamentin ja neuvoston direktiivin 2006/123/EY mukaisesti 16 päivänä lokakuuta 2009 tehdyn komission päätöksen 2009/767/EY, sellaisena kuin se on muutettuna komission päätöksellä 2010/425/EU ja komission täytäntöönpanopäätöksellä 2013/662/EU, 2 artiklan 4 kohdan mukaisesti tiedot, jotka jäsenvaltiot ovat ilmoittaneet komission päätöksen 2009/767/EY 2 artiklan 3 kohdan mukaisesti: + EU:Förteckning som, i enlighet med artikel 2.4 i kommissionens beslut av den 16 oktober 2009 om åtgärder som underlättar användningen av förfaranden på elektronisk väg genom gemensamma kontaktpunkter i enlighet med Europaparlamentets och rådets direktiv 2006/123/EG om tjänster på den inre marknaden, ändrat genom kommissionens beslut 2010/425/EU och kommissionens genomförandebeslut 2013/662/EU, innehåller den information som medlemsstaterna lämnat i enlighet med artikel 2.3 i kommissionens beslut 2009/767/EG. + EU:Popis koji, u skladu s člankom 2. stavkom 4. Odluke Komisije 2009/767/EZ od 16. listopada 2009. o utvrđivanju mjera kojima se olakšava uporaba postupaka elektroničkim putem preko „jedinstvenih kontaktnih točaka” u skladu s Direktivom 2006/123/EZ Europskog parlamenta i Vijeća o uslugama na unutarnjem tržištu, kako je izmijenjena Odlukom Komisije 2010/425/EU i Provedbenom odlukom Komisije 2013/662/EU, sadržava informacije o kojima su države članice izvijestile u skladu s člankom 2. stavkom 3. Odluke Komisije 2009/767/EZ: + + + https://eur-lex.europa.eu/eli/C/2026/1944/oj + https://ec.europa.eu/tools/lotl/eu-lotl-pivot-378.xml + https://ec.europa.eu/tools/lotl/eu-lotl-pivot-341.xml + https://ec.europa.eu/tools/lotl/eu-lotl-pivot-335.xml + https://ec.europa.eu/tools/lotl/eu-lotl-pivot-300.xml + https://ec.europa.eu/tools/lotl/eu-lotl-pivot-282.xml + https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=uriserv:OJ.C_.2019.276.01.0001.01.ENG + https://ec.europa.eu/tools/lotl/pivot-lotl-explanation.html + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#en + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#bg + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#es + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#cs + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#da + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#de + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#et + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#el + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#fr + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#it + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#lv + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#lt + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#hu + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#mt + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#nl + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#pl + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#pt + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#ro + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#sk + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#sl + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#fi + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#sv + https://ec.europa.eu/tools/lotl/eu-lotl-legalnotice.html#hr + + http://uri.etsi.org/TrstSvc/TrustedList/StatusDetn/EUlistofthelists + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUlistofthelists + + EU + + In accordance with Art. 4(3) of Commission Implementing Decision (EU) 2015/1505 of 8 September 2015 laying down technical specifications and formats relating to trusted lists pursuant to Article 22(5) of Regulation (EU) No 910/2014 of the European Parliament and of the Council on electronic identification and trust services for electronic transactions in the internal market, the present list contains the information notified by Member States pursuant to Art. 4(1) and Art. 4(2) of Commission Implementing Decision (EU) 2015/1505. +The European Commission maintains this website as an interoperability tool designed to facilitate the practical use of national Trusted Lists. Our goal is to keep this information timely and accurate. If errors are brought to our attention, we will try to correct them. However, the Commission accepts no responsibility or liability whatsoever with regard to the content of national Trusted Lists which lies exclusively with the Member States. +It is our goal to minimise disruption caused by technical errors. However, some data or information on our site may have been created or structured in files or formats that are not error-free and we cannot guarantee that our service will not be interrupted or otherwise affected by such problems. The European Commission accepts no responsibility with regard to such problems incurred as a result of using this site or any linked external sites. +This disclaimer is not intended to limit the liability of the European Commission in contravention of any requirements laid down in applicable national law nor to exclude its liability for matters which may not be excluded under that law. + съгласно член 4, параграф 3 от Решение за изпълнение (ЕС) № 2015/1505 на Комисията от 8 септември 2015 г. за определяне на техническите спецификации и форматите на доверителните списъци съгласно член 22, параграф 5 от Регламент (ЕС) № 910/2014 на Европейския парламент и на Съвета относно електронната идентификация и удостоверителните услуги при електронни трансакции на вътрешния пазар, съдържащ информацията, съобщена от държавите-членки съгласно член 4, параграфи 1 и 2 Решение за изпълнение (ЕС) № 2015/1505 на Комисията. +Европейската комисия поддържа този уебсайт като инструмент за оперативна съвместимост, чиято цел е да улесни използването на национални доверителни списъци. Наша цел е да поддържаме актуалността и точността на тази информация. Ако ни съобщите за допуснатигрешки, ще се постараем да ги коригираме. Въпреки това Комисията не поема никаква отговорност по отношение на съдържанието на националните доверителни списъци, за което отговорност носят изцяло държавите-членки. +Наша цел е да сведем до минимум проблемите, причинени от технически грешки. Въпреки това някои данни или информация на нашия сайт може да са създадени или структурирани във файлове или формати, податливи на грешки, и не можем да гарантираме, че нашитеуслуги няма да бъдат прекъснати или засегнати по друг начин от подобни проблеми. Европейската комисия не поема отговорност по отношение на такива проблеми, появили се в резултат от използването на този сайт или на други външни сайтове, свързани с него. +Настоящият отказ от отговорност няма за цел да ограничава отговорността на Европейската комисия в разрез с изискванията, заложени в приложимото национално законодателство, нито да я освобождава от отговорност в области, в които това не е възможно съгласно товазаконодателство. + De conformidad con el artículo 4, apartado 3, Decisión de Ejecución (UE) 2015/1505 de la Comisión, de 8 de septiembre de 2015, por la que se establecen las especificaciones técnicas y los formatos relacionados con las listas de confianza de conformidad con el artículo 22, apartado 5, del Reglamento (UE) n.° 910/2014 del Parlamento Europeo y del Consejo, relativo a la identificación electrónica y los servicios de confianza para las transacciones electrónicas en el mercado interior, la presente lista contiene la información notificada por los Estados miembros en virtud del artículo 4, apartados 1 y 2, Decisión de Ejecución (UE) 2015/1505 de la Comisión. +Con el presente sitio Internet la Comisión Europea quiere ofrecer una herramienta de interoperabilidad que facilite el uso práctico de las listas de confianza nacionales. Nuestro objetivo es mantener esta información actualizada y precisa. Trataremos de corregir los errores que se nos señalen. No obstante, la Comisión no asume responsabilidad alguna en relación con el contenido de las listas de confianza nacionales, que son de la exclusiva incumbencia de los Estados miembros. +Queremos reducir al mínimo los problemas ocasionados por errores de carácter técnico. No obstante, algunos datos o informaciones de nuestro sitio pueden haber sido creados u organizados en archivos o formatos no exentos de errores, y no podemos garantizar que nuestro servicio no se vea interrumpido o afectado de alguna otra manera. La Comisión no asume responsabilidad alguna por los problemas que puedan surgir al utilizar este sitio o sitios externos con enlaces al mismo. +La presente cláusula de exención de responsabilidad no tiene por objeto limitar la responsabilidad de la Comisión de forma contraria a lo dispuesto por las normativas nacionales aplicables ni excluir su responsabilidad en los casos en los que, en virtud de dichas normativas, no pueda excluirse. + V souladu s čl. 4 odst. 3 rozhodnutí Komise (EU) 2015/1505 ze dne 8. září 2015, kterým se stanoví technické specifikace a formáty důvěryhodných seznamů podle čl. 22 odst. 5 nařízení Evropského parlamentu a Rady (EU) č. 910/2014 o elektronické identifikaci a službách vytvářejících důvěru pro elektronické transakce na vnitřním trhu, tento seznam obsahuje informace oznámené členskými státy podle čl. 4 odst. 1 a 2 rozhodnutí Komise (EU) 2015/1505. +Tyto internetové stránky spravuje Evropská komise s cílem usnadnit praktické využívání důvěryhodných seznamů z jednotlivých členských států. Snažíme se poskytovat aktualizované a přesné informace. Snažíme se rovněž opravovat všechny chyby, na něž nás upozorníte. Komise však vylučuje jakoukoli odpovědnost za obsah důvěryhodných seznamů, neboť tuto odpovědnost nesou výhradně členské státy. +Snažíme se vyvarovat poruch způsobených technickými chybami. Některé údaje či informace na našich internetových stránkách však mohly být vytvořeny či strukturovány do souborů či formátů, které nejsou bezchybné, a proto nemůžeme zaručit, že naše služby nebudou v důsledku takových problémů přerušeny či jinak ovlivněny. Evropská komise odmítá jakoukoli odpovědnost za problémy, které nastanou v důsledku používání těchto stránek nebo externích stránek, na něž tyto stránky odkazují. +Záměrem tohoto prohlášení není omezit odpovědnost Evropské komise v případě porušení platných vnitrostátních právních předpisů ani vyloučit její odpovědnost v záležitostech, ve kterých ji podle těchto předpisů vyloučit nelze. + I overensstemmelse med artikel 4, stk. 3, i Kommissionens gennemførelsesforordning (EU) 2015/1505 af 8. september 2015 om fastlæggelse af tekniske specifikationer og formater for positivlister i henhold til artikel 22, stk. 5, i Europa-Parlamentets og Rådets forordning (EU) nr. 910/2014 om elektronisk identifikation og tillidstjenester til brug for elektroniske transaktioner på det indre marked, indeholder denne liste de oplysninger, som medlemslandene har afgivet i henhold til artikel 4, stk. 1 og 2 i Kommissionens gennemførelsesforordning (EU) 2015/1505. +Kommissionen har her på webstedet samlet information om de nationale positivlister, så det er lettere at anvende dem i praksis. Vi tilstræber, at oplysningerne er korrekte og ajourførte. Hvis vi bliver opmærksomme på fejl, søger vi at rette dem. Kommissionen påtager sig imidlertid intet ansvar for indholdet i de nationale positivlister. Ansvaret påhviler udelukkende medlemslandene. +Vi tilstræber så vidt muligt at mindske forstyrrelser forårsaget af tekniske problemer. Dog kan visse data eller andre oplysninger på webstedet være blevet struktureret i filer eller formater, som ikke er fejlfrie, og vi kan ikke garantere, at vores service ikke afbrydes eller i øvrigt ikke påvirkes af den slags problemer. Kommissionen påtager sig intet ansvar for sådanne ulemper, der måtte opstå som følge af brugen af dette websted eller andre tilknyttede eksterne websteder. +Hensigten med denne erklæring om ansvarsfraskrivelse er hverken at begrænse Kommissionens ansvar på en måde, der strider med eventuelle krav ifølge gældende national ret, eller at udelukke Europa-Kommissionens ansvar i tilfælde, hvor ansvar ikke kan udelukkes ifølge national ret. + Diese Liste enthält die von den Mitgliedstaaten übermittelten Angaben und steht damit im Einklang mit Artikel 4 Absatz 3 des Durchführungsbeschlusses (EU) 2015/1505 der Kommission vom 8. September 2015 über technische Spezifikationen und Formate in Bezug auf Vertrauenslisten gemäß Artikel 22 Absatz 5 der Verordnung (EU) Nr. 910/2014 des Europäischen Parlaments und des Rates über elektronische Identifizierung und Vertrauensdienste für elektronische Transaktionen im Binnenmarkt in Übereinstimmung mit Artikel 4 Absätze 1 und 2 den Durchführungsbeschluss (EU) 2015/1505 der Kommission. +Diese Website der Europäischen Kommission ist als Schnittstelle gedacht, die die Verwendung nationaler vertrauenswürdiger Listen in der Praxis vereinfachen soll. Wir sind bestrebt, die einschlägigen Informationen inhaltlich richtig und rechtzeitig bereitzustellen. Wir bemühen uns, Irrtümer zu berichtigen, die uns zur Kenntnis gebracht werden. Die Kommission übernimmt jedoch keine Verantwortung oder Haftung für den Inhalt der nationalen vertrauenswürdigen Listen, für die ausschließlich die Mitgliedstaaten zuständig sind. +Wir arbeiten darauf hin, technisch bedingte Störungen auf ein Mindestmaß zu reduzieren. Dennoch kann es vorkommen, dass Daten oder Informationen auf unserer Website in fehlerhaften Dateien oder Formaten vorliegen. Wir können also nicht garantieren, dass der Arbeitsablauf durch derartige Probleme nicht gestört oder anderweitig beeinträchtigt wird. Die Europäische Kommission übernimmt für derartige Störungen beim Besuch dieser Website oder damit verbundener externer Sites keine Verantwortung. +Mit der vorliegenden Haftungsausschlussklausel soll die Haftung der Europäischen Kommission bei Nichteinhaltung der einschlägigen nationalen Rechtsvorschriften weder eingeschränkt noch in Fällen ausgeschlossen werden, in denen ein Ausschluss nach diesen Rechtsvorschriften nicht möglich ist. + Vastavalt Komisjoni 8. septembri 2015. aasta rakendusotsus (EL) 2015/1505, millega kehtestatakse usaldusnimekirjade tehnilised kirjeldused ja vormingud vastavalt Euroopa Parlamendi ja nõukogu määruse (EL) nr 910/2014 (e-identimise ja e-tehingute jaoks vajalike usaldusteenuste kohta siseturul) artikli 22 lõikele 5 artikli 4 lõikele 3, sisaldab käesolev loetelu liikmesriikide vastavalt komisjoni rakendusotsuse (EL) 2015/1505 artikli 4 lõikele 1 ja artikli 4 lõikele 2 esitatud teavet. +Euroopa Komisjon haldab asjaomast veebisaiti koostalitlusvõime vahendina, mis hõlbustab liikmesriikide usaldusnimekirjade praktilist kasutamist. Eesmärk on pakkuda õigeaegset ja täpset teavet. Märgatud vigu püüame parandada. Samas ei võta komisjon endale vastutust ega mingeid kohustusi liikmesriikide usaldusnimekirjade sisu suhtes, mille eest vastutavad üksnes liikmesriigid ise. +Meie eesmärk on vähendada tehniliste vigade tõttu tekkinud häireid. Osa veebisaidil olevatest andmetest või teabest võib aga olla loodud või paigutatud vigastesse failidesse või vormingutesse ning seega ei saa me tagada, et sellised probleemid meie teenust ei häiri või muul moel ei mõjuta. Euroopa Komisjon ei võta endale vastutust seoses kõnealuste probleemidega, mis tulenevad käesoleva veebisaidi või seonduvate välissaitide kasutamisest. +Käesoleva vastutamatusesätte eesmärk ei ole Euroopa Komisjoni vastutuse piiramine, mis oleks vastuolus kohaldatavas liikmesriigi õigusaktis sätestatud nõuetega ega komisjoni vastutuse kõrvaldamine küsimustes, mida ei tohi asjaomase õigusakti alusel kõrvale jätta. + Σύμφωνα με το άρθρο 4 παράγραφος 3 της εκτελεστικής απόφασης (ΕΕ) 2015/1505 της Επιτροπής, της 8ης Σεπτεμβρίου 2015, περί καθορισμού των τεχνικών προδιαγραφών και των μορφότυπων των καταλόγων εμπίστευσης σύμφωνα με το άρθρο 22 παράγραφος 5 του κανονισμού (ΕΕ) αριθ. 910/2014 του Ευρωπαϊκού Κοινοβουλίου και του Συμβουλίου σχετικά με την ηλεκτρονική ταυτοποίηση και τις υπηρεσίες εμπιστοσύνης για τις ηλεκτρονικές συναλλαγές στην εσωτερική αγορά, ο παρών κατάλογος περιέχει τις πληροφορίες που γνωστοποιούν τα κράτη μέλη σύμφωνα με το άρθρο 4 παράγραφοι 1 και 2 της απόφασης 2009/767/EΚ της Επιτροπής. +Ο δικτυακός αυτός τόπος της Ευρωπαϊκής Επιτροπής είναι ένα διαλειτουργικό εργαλείο σχεδιασμένο για να διευκολύνει τη χρήση των εθνικών καταλόγων εμπίστευσης.. Στόχος μας είναι να παρέχουμε ακριβή και επικαιροποιημένα στοιχεία. Αν επισημανθούν σφάλματα θα καταβληθεί κάθε προσπάθεια για τη διόρθωσή τους.Ωστόσο, η Επιτροπή δεν φέρει καμία ευθύνη όσον αφορά το περιεχόμενο των εθνικών καταλόγων εμπίστευσης, για τους οποίους την αποκλειστική ευθύνη φέρουν τα κράτη μέλη. +Καταβάλλουμε κάθε προσπάθεια ώστε να ελαχιστοποιήσουμε τις διακοπές που προκαλούνται από τεχνικά προβλήματα. Ωστόσο, ορισμένα δεδομένα ή πληροφορίες που περιέχει ο δικτυακός τόπος μπορεί να έχουν δημιουργηθεί ή οργανωθεί σε αρχεία ή μορφότυπους που περιέχουν σφάλματα και γι΄αυτό δεν μπορούμε να εγγυηθούμε ότι η υπηρεσία μας δεν θα διακοπεί, ή δεν θα επηρεαστεί με άλλο τρόπο, από τέτοια προβλήματα. Η Επιτροπή δεν φέρει καμιά ευθύνη όσον αφορά τέτοια προβλήματα που ανακύπτουν κατά τη χρήση αυτού του δικτυακού τόπου, ή οποιουδήποτε άλλου συνδεδεμένου δικτυακού τόπου. +Η παρούσα δήλωση αποποίησης ευθύνης δεν έχει σκοπό να περιορίσει την ευθύνη της Ευρωπαϊκής Επιτροπής κατά τρόπο που αντίκειται στις απαιτήσεις της ισχύουσας εθνικής νομοθεσίας ούτε να αποκλείσει την ευθύνη της για ζητήματα για τα οποία δεν μπορεί να αποκλειστεί δυνάμει της εν λόγω νομοθεσίας. + Conformément à l'article 4, paragraphe 3 de la Décision d'exécution (UE) 2015/1505 de la Commission du 8 septembre 2015 établissant les spécifications techniques et les formats relatifs aux listes de confiance visées à l'article 22, paragraphe 5, du règlement (UE) n° 910/2014 du Parlement européen et du Conseil sur l'identification électronique et les services de confiance pour les transactions électroniques au sein du marché intérieur, la présente liste contient les informations notifiées par les États membres conformément à l'article 4, paragraphe 1 et à l'article 4 paragraphe 2, de la décision d'exécution (UE) 2015/1505 de la Commission. +Le présent site de la Commission européenne constitue un outil d'interopérabilité destiné à faciliter l'utilisation des listes de confiance nationales. Notre objectif est de diffuser des informations exactes et à jour. Nous nous efforcerons de corriger les erreurs qui nous seront signalées. Toutefois, la Commission n'assume pas la responsabilité du contenu des listes de confiance nationales, qui incombe exclusivement aux États membres. +Nous souhaitons limiter autant que possible les inconvénients occasionnés par des erreurs techniques. Cependant, certaines données ou informations présentes sur notre site peuvent avoir été créées ou structurées dans des fichiers ou des formats qui ne sont pas exempts d'erreurs. Il nous est donc impossible de garantir que notre service ne sera pas interrompu ou autrement affecté par de tels problèmes. La Commission décline toute responsabilité quant aux éventuels problèmes de ce type, résultant d'une utilisation du présent site ou de tout autre site extérieur auquel il renvoie. +La présente clause de non-responsabilité n'a pas pour but de limiter la responsabilité de la Commission de manière contraire aux dispositions prévues dans les législations nationales applicables ou de dégager sa responsabilité dans des cas où elle ne peut l'être en vertu desdites législations. + Conformemente all'articolo 4, paragrafo 3, della decisione di esecuzione (UE) 2015/1505 della Commissione dell’8 settembre 2015, che stabilisce le specifiche tecniche e i formati relativi agli elenchi di fiducia di cui all’articolo 22, paragrafo 5, del regolamento (UE) n. 910/2014 del Parlamento europeo e del Consiglio in materia di identificazione elettronica e servizi fiduciari per le transazioni elettroniche nel mercato interno , la presente lista contiene le informazioni notificate dagli Stati membri a norma dell'articolo 4, paragrafi 1 e 2, della decisione di esecuzione (UE) 2015/1505 della Commissione. +Il presente sito della Commissione europea assicura l'interoperabilità necessaria per facilitare l'uso pratico degli elenchi di fiducia nazionali. L'obiettivo perseguito è quello di fornire un'informazione aggiornata e precisa. Qualora dovessero essere segnalati degli errori, si provvederà a correggerli. La Commissione non si assume alcuna responsabilità per quanto riguarda il contenuto degli elenchi di fiducia nazionali, che è di competenza esclusiva degli Stati membri. +È nostra cura ridurre al minimo le disfunzioni imputabili a problemi tecnici. Parte dei dati o delle informazioni presenti nel sito potrebbero tuttavia essere stati inseriti o strutturati in archivi o formati non esenti da errori. Non possiamo pertanto garantire che il servizio non subisca interruzioni o che non sia in altro modo influenzato da tali problemi. La Commissione non si assume alcuna responsabilità per gli eventuali problemi derivanti dall'utilizzazione del presente sito o di eventuali siti esterni ad esso collegati. +La presente clausola di esclusione della responsabilità non ha lo scopo di limitare la responsabilità della Commissione in violazione di disposizioni della legge nazionale applicabile, né di escluderla nei casi in cui non può essere esclusa in forza di detta legge. + Šajā sarakstā ir iekļauta informācija, kuru dalībvalstis Komisijai ir paziņojušas saskaņā ar 4. panta 3. punktu Komisijas 2015. gada 8. septembra Īstenošanas lēmums (ES) 2015/1505, kurā saskaņā ar Eiropas Parlamenta un Padomes Regulas (ES) Nr. 910/2014 par elektronisko identifikāciju un uzticamības pakalpojumiem elektronisko darījumu veikšanai iekšējā tirgū 22. panta 5. punktu izklāstītas tehniskās specifikācijas un formāti, kas attiecas uz uzticamības sarakstiem. Šis saraksts publicēts atbilstīgi Komisijas Īstenošanas lēmuma (ES) 2015/1505 4. panta 1. un 2. punktu. +Eiropas Komisija uztur šo tīmekļa vietni, lai sekmētu dalībvalstu uzticamo sarakstu praktisku un savstarpēju izmantošanu. Mēs darām visu, lai nodrošinātu, ka šī informācija ir sniegta laicīgi un ir pareiza. Centīsimies labot norādītās kļūdas. Tomēr Komisija neuzņemas nekādu atbildību vai saistības attiecībā uz dalībvalstu uzticamajos sarakstos sniegto informāciju, jo par tiem atbild vienīgi dalībvalstis. +Mēs darām visu, lai līdz minimumam samazinātu traucējumus, ko rada tehniskas kļūmes. Tomēr atsevišķos gadījumos dati vai informācija, kas iekļauta mūsu vietnē, ir sagatavota vai organizēta datnēs vai formātos, kas nefunkcionē nevainojami, un mēs nevaram garantēt, ka šādas problēmas nepārtrauks vai citādi neietekmēs mūsu pakalpojumus. Eiropas Komisija neuzņemas nekādu atbildību par problēmām, kas rodas, izmantojot šo vietni vai kādu citu ārēju vietni, uz kuru esam snieguši hipersaiti. +Šī atruna neierobežo Eiropas Komisijas atbildību tad, ja nav ievērotas spēkā esošo valsts tiesību aktu prasības, un neierobežo tās atbildību gadījumos, kad saskaņā ar tiesību aktiem tai atbildība ir jāuzņemas. + Remiantis 2015 m. rugsėjo 8 d. Komisijos įgyvendinimo sprendimas (ES) 2015/1505, kuriuo pagal Europos Parlamento ir Tarybos reglamento (ES) Nr. 910/2014 dėl elektroninės atpažinties ir elektroninių operacijų patikimumo užtikrinimo paslaugų vidaus rinkoje 22 straipsnio 5 dalį nustatomos patikimų sąrašų techninės specifikacijos ir formatai, 4 straipsnio 3 dalimi, šiame sąraše pateikiama informacija, kurią valstybės narės perdavė pagal Komisijos įgyvendinimo sprendimo (ES) 2015/1505 4 straipsnio 1 ir 2. +Ši Europos Komisijos administruojama interneto svetainė – sąveiki priemonė, skirta praktiniam naudojimuisi valstybių narių patikimais sąrašais palengvinti. Siekiame laiku teikti tikslią informaciją ir ištaisyti visas pastebėtas klaidas. Tačiau Komisija neprisiima atsakomybės ar teisinių įsipareigojimų dėl valstybių narių patikimų sąrašų turinio. Už jį atsakingos tik valstybės narės. +Siekiame, kad būtų kuo mažiau nesklandumų dėl techninių klaidų. Tačiau tam tikri mūsų interneto svetainėje skelbiami duomenys gali būti sukurti ar susisteminti tokiose rinkmenose arba tokiais formatais, kuriuose pasitaiko klaidų, todėl negalime užtikrinti, kad tokios problemos nesutrikdys mūsų darbo ar jo kaip nors kitaip nepaveiks. Europos Komisija neprisiima atsakomybės už tokio pobūdžio problemas, kylančias naudojantis šia interneto svetaine arba kitomis su ja susietomis išorės svetainėmis. +Šiuo atsakomybės apribojimu nesiekiama sumažinti Europos Komisijos teisinių įsipareigojimų nepažeisti jokių taikytinų nacionalinės teisės reikalavimų ar neprisiimti teisinių įsipareigojimų už tai, už ką pagal tą teisę nuo atsakomybės neatleidžiama. + A Bizottság 2015. szeptember 8-i (EU) 2015/1505 végrehajtási határozata a belső piacon történő elektronikus tranzakciókhoz kapcsolódó elektronikus azonosításról és bizalmi szolgáltatásokról szóló 910/2014/EU európai parlamenti és tanácsi rendelet 22. cikkének (5) bekezdése szerinti bizalmi listákhoz kapcsolódó technikai specifikációk és formátumok meghatározásáról bizottsági határozat 4. cikkének (3) bekezdése értelmében a jelen lista azokat az információkat tartalmazza, amelyeket a tagállamok a (EU) 2015/1505 bizottsági végrehajtási határozat 4. cikkének (1) és (2) bekezdésben értelmében jelentettek be. +Az Európai Bizottság e weblapot a kölcsönös átjárhatóság elősegítésére tartja fönn, abból a célból, hogy megkönnyítse a megbízható szolgáltatók listájának használatát. Célunk az, hogy ezek az információk naprakészek és pontosak legyenek. Amennyiben arról értesülünk, hogy a webhelyen hibás információk szerepelnek, azokat igyekszünk kijavítani. A Bizottság semmilyen felelősséget sem vállal a nemzeti megbízható szolgáltatók listájának tartalmáért, mert azért kizárólag a tagállamok felelősek. +Arra törekszünk, hogy az esetleges technikai hibák a lehető legkisebb mértékben okozzanak fennakadásokat a portál működésében. Előfordulhat ugyanakkor, hogy a portál oldalain található adatok vagy információk olyan fájlokban vagy formátumokban állnak rendelkezésre, amelyek nem mentesek a hibáktól; ilyen esetekben nem tudjuk garantálni, hogy ezek a problémák nem okoznak fennakadásokat a webhely használata során. Az Európai Bizottság nem vállal felelősséget a honlap (vagy a belinkelt külső honlapok) használatából fakadó problémákért. +E jogi nyilatkozat nem korlátozza az Európai Bizottságnak az alkalmazandó közösségi jogban lefektetett követelményekből fakadó felelősségét, és nem zárja ki a Bizottság felelősségét olyan ügyekben, amelyekért az említett jog értelmében felelősségre vonható. + F'konformità mal-Art. 4(3) tad-Deċiżjoni ta' Implimentazzjoni tal-Kummissjoni (UE) 2015/1505 (4) tat-8 ta’ Settembru 2015 li tistabbilixxi l-ispeċifikazzjonijiet u l-formati tekniċi marbutin mal-listi ta’ fiduċja skont l-Artikolu 22(5) tar-Regolament (UE) Nru 910/2014 tal-Parlament Ewropew u tal-Kunsill dwar l-identifikazzjoni elettronika u s-servizzi fiduċjarji għal tranżazzjonijiet elettroniċi fis-suq intern, dan l-elenku fih l-informazzjoni notifikata mill-Istati Membri skont l-Artikoli 4.1 u 4.2 tad-Deċiżjoni ta’ Implimentazzjoni tal-Kummissjoni (UE) 2015/1505. +Il-Kummissjoni Ewropea żżomm dan is-sit bħala strument ta' interoperabilità ddisinnjat biex jiffaċilita l-użu prattiku tal-Listi ta' Fiduċja nazzjonali. L-għan tagħna hu li nżommu din l-informazzjoni aġġornata u eżatta. Jekk tiġbdulna l-attenzjoni li hemm żbalji, aħna nippruvaw nikkoreġuhom. Madanakollu l-Kummissjoni ma taċċetta l-ebda responsabbiltà fir-rigward tal-kontenut tal-Listi ta' Fiduċja nazzjonali li taqa' esklussivament fuq l-Istati Membri. +Huwa l-għan tagħna li nnaqqsu t-tfixkil ikkawżat mill-iżbalji tekniċi. Madanakollu, xi dejta jew informazzjoni fuq is-sit tagħna setgħet inħolqot jew ġiet strutturata f’fajls jew formati li mhumiex ħielsa mill-iżbalji u ma nistgħux niggarantixxu li s-servizz tagħna ma jiġix interrott jew b’xi mod effettwat minn problemi bħal dawn. Il-Kummissjoni ma tieħu l-ebda responsabbiltà għal dawn il-problemi mġarrba bħala riżultat tal-użu ta' dan is-sit jew kwalunkwe siti esterni relatati. +Din ir-rinunzja mhijiex maħsuba biex tillimita r-responsabbiltà tal-Kummissjoni fil-kontravenzjoni ta' kwalunkwe rekwiżit stipulat fil-liġi applikabbli tal-Komunità, l-anqas biex tneħħi r-responsabbiltà għal kwistjonijiet li jistgħu ma jkunux esklużi taħt dik il-liġi. + Overeenkomstig artikel 4, lid 3, van Uitvoeringsbesluit (EU) 2015/1505 van de Commissie van 8 september 2015 tot vaststelling van de technische specificaties en formaten van vertrouwenslijsten overeenkomstig artikel 22, lid 5, van Verordening (EU) nr. 910/2014 van het Europees Parlement en de Raad betreffende elektronische identificatie en vertrouwensdiensten voor elektronische transacties in de interne markt, bevat deze lijst de door de lidstaten meegedeelde gegevens op grond van artikel 4, leden 1 en 2, van Uitvoeringsbesluit (EU) 2015/1505 van de Commissie. +De Europese Commissie wil met deze website het gebruik van de vertrouwenslijsten vergemakkelijken. Ons doel is up-to-date en nauwkeurige informatie aan te bieden. Gesignaleerde fouten worden zo snel mogelijk gecorrigeerd. De Commissie aanvaardt echter geen enkele verantwoordelijkheid of aansprakelijkheid met betrekking tot de informatie op de vertrouwenslijsten. De verantwoordelijkheid hiervoor ligt uitsluitend bij de EU-landen. +Wij proberen onderbrekingen door technische storingen zoveel mogelijk te beperken. Sommige gegevens of informatie op onze site kan zijn aangemaakt of omgezet in bestanden of formaten die niet foutloos zijn. Wij kunnen niet uitsluiten dat onze dienstverlening door dergelijke problemen wordt verstoord. De Commissie aanvaardt geen aansprakelijkheid voor die problemen die zich als gevolg van het gebruik van deze site of van andere daarmee verbonden externe sites mochten voordoen. +Met deze disclaimer wordt niet beoogd de aansprakelijkheid van de Commissie te beperken in strijd met de in de toepasselijke EU-wetgeving vervatte vereisten, noch haar aansprakelijkheid uit te sluiten voor aangelegenheden die uit hoofde van die wetgeving niet mogen worden uitgesloten. + Zgodnie z art. 4 ust. 3 decyzji wykonawczej Komisji (UE) 2015/1505 z dnia 8 września 2015 r. ustanawiająca specyfikacje techniczne i formaty dotyczące zaufanych list zgodnie z art. 22 ust. 5 rozporządzenia Parlamentu Europejskiego i Rady (UE) nr 910/2014 w sprawie identyfikacji elektronicznej i usług zaufania w odniesieniu do transakcji elektronicznych na rynku wewnętrznym, wykaz ten zawiera informacje przekazane przez państwa członkowskie zgodnie z artykułami 4.1 i 4.2 decyzji wykonawczej Komisji (UE) 2015/1505. +Ta strona internetowa Komisji Europejskiej ma ułatwić korzystanie z krajowych zaufanych list. Naszym celem jest dostarczanie aktualnych i ścisłych informacji. Jeśli zostaniemy powiadomieni o błędach, dołożymy wszelkich starań, aby je skorygować. Komisja nie ponosi jednak żadnej odpowiedzialności za treść krajowych zaufanych list, za którą odpowiadają wyłącznie państwa członkowskie. +Naszym celem jest ograniczenie do minimum zakłóceń wynikających z błędów technicznych. Jednak niektóre z zamieszczonych w tym serwisie danych lub informacji mogły być utworzone lub zamieszczone w plikach lub formatach, które nie są wolne od błędów, w związku z czym nie możemy zagwarantować, że problemy takie nie spowodują przerw w dostępie do serwisu lub innych zakłóceń w jego funkcjonowaniu. Komisja Europejska nie bierze odpowiedzialności w związku z tego rodzaju problemami będącymi następstwem korzystania z tego serwisu lub jakichkolwiek serwisów zewnętrznych, do których odsyła niniejszy serwis. +Niniejsze zastrzeżenie nie ma na celu ograniczenia odpowiedzialności Komisji Europejskiej w przypadku naruszenia jakichkolwiek wymagań określonych w stosownych przepisach prawa krajowego ani wyłączenia jej odpowiedzialności za kwestie, które na gruncie tego prawa nie podlegają wyłączeniu. + Em conformidade com o n.º 3 do artigo 4.° da Decisão de Execução (UE) 2015/1505 da Comissão, de 8 de setembro de 2015, que estabelece as especificações técnicas e os formatos relativos às listas de confiança, nos termos do artigo 22.º, n.º 5, do Regulamento (UE) n.º 910/2014 do Parlamento Europeu e do Conselho relativo à identificação eletrónica e aos serviços de confiança para as transações eletrónicas no mercado interno, a presente lista contém as informações notificadas pelos Estados-Membros ao abrigo do n.º 1 do artigo 4.° e n.º 2 do artigo 4.° da Decisão de Execução (UE) 2015/1505 da Comissão. +Este sítio Web da Comissão Europeia assegura a interoperabilidade necessária para facilitar uma utilização eficaz das listas aprovadas e tem por objectivo fornecer informações exactas e actualizadas. Procuraremos corrigir todos os erros que nos forem comunicados. Contudo, a Comissão declina toda e qualquer responsabilidade quanto ao conteúdo das listas aprovadas nacionais, que incumbe exclusivamente aos Estados-Membros. +É nosso objectivo reduzir ao mínimo os inconvenientes causados por erros técnicos. Contudo, determinados dados constantes do nosso sítio podem ter sido criados ou estruturados em ficheiros ou formatos não isentos de erros, pelo que não podemos garantir um serviço sem interrupções ou perturbações. A Comissão declina qualquer responsabilidade por eventuais problemas que surjam na sequência da consulta deste sítio ou de quaisquer sítios externos a que as ligações dêem acesso. +A presente declaração de exoneração de responsabilidade não pretende limitar a responsabilidade da Comissão Europeia de uma forma que contrarie o disposto na legislação nacional aplicável, nem excluir a sua responsabilidade nos casos em que tal não é permitido por essa legislação. + În conformitate cu articolul 4 alineatul (3) din Decizia de punere în aplicare (UE) 2015/1505 a Comisiei din 14 octombrie 2013 de modificare a Deciziei 2009/767/CE în ceea ce privește crearea, menținerea și publicarea listelor sigure de prestatori de servicii de certificare supravegheați/acreditați de către statele membre, prezenta listă conține informațiile notificate de statele membre în conformitate cu articolul 4 alineatele (1) și (2) din Decizia de punere în aplicare (UE) 2015/1505 a Comisiei. +Comisia Europeană utilizează acest site ca instrument de facilitare a utilizării Listelor naționale sigure, prin sporirea interoperabilității. Scopul nostru este ca aceste informații să fie actualizate și exacte. În cazul în care ni se vor semnala erori, vom încerca să le corectăm. Totuși, Comisia nu îșiasumă niciun fel de responsabilitate cu privire la conținutul Listelor naționale sigure, care intră, integral, în sarcina statelor membre. +De asemenea, ne propunem să reducem consecințele negative cauzate de erori tehnice. Cu toate acestea, este posibil ca unele date sau informații de pe site-ul nostru să fi fost create sau structurate în fișiere sau formate care pot prezenta erori. Prin urmare, nu putem garanta că serviciile noastrenu vor fi întrerupte sau afectate de asemenea probleme. Comisia Europeană nu își asumă nicio responsabilitate cu privire la eventuale probleme survenite ca urmare a utilizării acestui site sau a oricăror alte site-uri externe la care face trimitere. +Această denegare de responsabilitate nu este destinată să limiteze răspunderea Comisiei Europene într-un mod care contravine reglementărilor prevăzute de legislația internă aplicabilă și nu exclude răspunderea sa în cazuri care, în conformitate cu legislația respectivă, aceasta nu poate fiexclusă. + V súlade s článkom 4 ods. 3 vykonávacieho rozhodnutia Komisie (EÚ) 2015/1505 z 8. septembra 2015, ktorým sa ustanovujú technické špecifikácie a formáty týkajúce sa dôveryhodných zoznamov podľa článku 22 ods. 5 nariadenia Európskeho parlamentu a Rady (EÚ) č. 910/2014 o elektronickej identifikácii a dôveryhodných službách pre elektronické transakcie na vnútornom trhu, tento zoznam obsahuje informácie oznámené členskými štátmi podľa článkov 4 ods. 1 a 2 vykonávacieho rozhodnutia Komisie (EÚ) 2015/1505. +Európska komisia spravuje tieto internetové stránky ako interoperabilný nástroj, ktorý slúži na uľahčenie praktického využitia zoznamov dôveryhodných informácií. Naším cieľom je poskytovať tieto informácie včas a správne. Ak budeme upozornení na chyby, pokúsime sa ich napraviť.Komisia však nepreberá žiadnu zodpovednosť, ani inak neručí za obsah zoznamov dôveryhodných informácií, ktoré poskytli členské štáty. +Je naším cieľom minimalizovať technické chyby. Niektoré informácie alebo údaje na tejto webovej lokalite však mohli byť vytvorené v chybných súboroch alebo formátoch, a preto nemožno zaručiť, že tieto problémy nespôsobia výpadok alebo inú poruchu našej webovej lokality. Komisia nenesie žiadnu zodpovednosť za podobné chyby, ktoré sa zistia pri používaní tejto lokality alebo pridružených externých lokalít. +Zámerom tohto vyhlásenia o odmietnutí zodpovednosti nie je obmedzenie zodpovednosti Európskej komisie v rozpore s požiadavkami ustanovenými v príslušných vnútroštátnych predpisoch ani vylúčenie jej zodpovednosti vo veciach, v ktorých ju podľa týchto predpisov nie je možné vylúčiť. + Seznam v skladu s členom 4(3) Izvedbenega sklepa Komisije (EU) 2015/1505 z dne 8. septembra 2015 o določitvi tehničnih specifikacij in formatov v zvezi z zanesljivimi seznami v skladu s členom 22(5) Uredbe (EU) št. 910/2014 Evropskega parlamenta in Sveta o elektronski identifikaciji in storitvah zaupanja za elektronske transakcije na notranjem trgu, vsebuje informacije, ki so jih v skladu s členom 4 (1) in (2) Izvedbenega sklepa Komisije (EU) 2015/1505 sporočile države članice. +Evropska komisija si prizadeva izboljšati praktično uporabo zanesljivih seznamov držav članic. Temu je namenjeno tudi to spletišče. Želimo zagotavljati pravočasne in točne informacije. Če nas boste opozorili na morebitne napake, jih bomo poskušali čimprej odpraviti. Komisija ne prevzema nikakršne zakonske ali druge odgovornosti glede vsebine nacionalnih zanesljivih seznamov, za katero so odgovorne izključno države članice. +Uporabnikom želimo omogočiti nemoteno uporabo s čim manj tehničnimi napakami. Vendar so lahko nekateri podatki in informacije na našem spletišču v datotekah ali obliki, ki niso popolnoma brez napak, zato ne moremo zagotoviti, da takšne težave ne bodo vplivale na zagotavljanje naših storitev. Komisija ne prevzema nobene odgovornosti v zvezi s težavami, ki so posledica uporabe tega spletišča ali povezanega zunanjega spletišča. +Izjava ne omejuje odgovornosti Evropske komisije pri kakršnem koli delovanju v nasprotju z veljavno nacionalno zakonodajo, niti ne izključuje odgovornosti za dejanja, ki jih v skladu s to zakonodajo ni mogoče izključiti. + Tämä luettelo sisältää komission täytäntöönpanopäätöksen (EU) 2015/1505 4 artiklan 3 kohdan mukaisesti tiedot, jotka EU-maat ovat toimittaneet komission täytäntöönpanopäätöksen (EU) 2015/1505 4 artiklan 1 ja 2 kohdan mukaisesti (Komission täytäntöönpanopäätös (EU) 2015/1505, annettu 8 päivänä syyskuuta 2015, luotettujen luetteloiden teknisten eritelmien ja muotoseikkojen vahvistamisesta sähköisestä tunnistamisesta ja sähköisiin transaktioihin liittyvistä luottamuspalveluista sisämarkkinoilla annetun Euroopan parlamentin ja neuvoston asetuksen (EU) N:o 910/2014 22 artiklan 5 kohdan mukaisesti). +Euroopan komissio ylläpitää tätä verkkosivustoa helpottaakseen kansallisten luotettavien luetteloiden käyttöä. Pyrimme pitämään tiedot ajantasaisina ja virheettöminä. Pyrimme korjaamaan tietoomme tulleet virheet. Komissio ei kuitenkaan voi olla vastuussa kansallisten luotettavien luetteloiden sisällöstä, joka on yksinomaan jäsenvaltioiden vastuulla. +Tavoitteenamme on minimoida teknisten häiriöiden aiheuttamat haitat. Jotkin tiedot sivustollamme on voitu luoda tai muotoilla sellaiseen muotoon tai sellaisiin tiedostoihin, jotka eivät ole virheettömiä, emmekä voi taata, ettei palvelumme keskeydy tai etteivät kyseiset ongelmat muutoin vaikuta siihen. Euroopan komissio ei vastaa ongelmista, jotka johtuvat tämän sivuston tai siihen linkitettyjen ulkopuolisten sivustojen käytöstä. +Tämän vastuuvapauslausekkeen tarkoituksena ei ole rajoittaa Euroopan komission vastuuta vastoin sovellettavan kansallisen lain vaatimuksia tai poistaa komission vastuuta seikoista, joiden osalta vastuuta ei sovellettavan kansallisen lain mukaan voida poistaa. + Av listan framgår var du kan hitta den information som EU-länderna har anmält, och som kommissionen måste tillhandahålla, enligt artikel 4.1, 4.2 och 4.3 i kommissionens genomförandebeslut (EU) 2015/1505 av den 8 september 2015 om fastställande av tekniska minimispecifikationer och format rörande förteckningar över betrodda tjänsteleverantörer i enlighet med artikel 22.5 i Europaparlamentets och rådets förordning (EU) nr 910/2014 om elektronisk identifiering och betrodda tjänster för elektroniska transaktioner på den inre marknaden. +Vi har samlat informationen på den här webbplatsen, så att du lättare ska kunna använda den i praktiken. Vi strävar efter att hålla informationen aktuell och korrekt. Om felaktigheter kommer till vår kännedom, försöker vi att rätta till dem. Vi frånsäger oss dock allt ansvar för de nationella förteckningarna. Medlemsländerna ansvarar helt och hållet själva för innehållet. +Vi strävar efter att så långt som möjligt undvika tekniska störningar. En del uppgifter eller information på vår sida kan dock ha skapats eller strukturerats i filer eller format som inte är felfria. Vi kan inte garantera att den service vi tillhandahåller kommer att vara fri från avbrott eller andra störningar som har att göra med sådana problem. Kommissionen frånsäger sig allt ansvar för problem som kan uppstå till följd av att denna webbplats eller någon av dess länkar har använts. +Denna ansvarsfriskrivning är inte avsedd att inskränka kommissionens ansvar i strid med tillämplig nationell lagstiftning eller att utesluta ansvar för kommissionen i de fall där friskrivning inte får ske enligt sådan lagstiftning. + U skladu s člankom 4. stavkom 3. Provedbene odluke Komisije (EU) 2015/1505 оd 8. rujna 2015. o utvrđivanju tehničkih specifikacija i formata koji se odnose na pouzdane popise u skladu s člankom 22. stavkom 5. Uredbe (EU) br. 910/2014 Europskog parlamenta i Vijeća o elektroničkoj identifikaciji i uslugama povjerenja za elektroničke transakcije na unutarnjem tržištu, trenutačni popis sadržava informacije o kojima su države članice izvijestile u skladu s člankom 4. stavkom 1. i člankom 4. stavkom 2. Provedbene odluke Komisije (EU) 2015/1505. +Europska Komisija održava ovo web-mjesto kao sredstvo za postizanje interoperabilnosti koje je napravljeno kako bi olakšalo praktičnu primjenu nacionalnih pouzdanih popisa. Naš je cilj ove informacije održavati pravodobnim i točnim. Ukaže li nam se na pogreške, pokušat ćemo ih otkloniti. No, Komisija ne preuzima nikakvu odgovornost za sadržaj nacionalnih pouzdanih popisa, jer su za njega odgovorne isključivo države članice. Cilj nam je smetnje uzrokovane tehničkim pogreškama svesti na minimum. Međutim, postoji mogućnost da su neki podaci i informacije na našim stranicama izrađeni ili strukturirani u datotekama ili formatima koji nisu bez pogrešaka te stoga ne možemo jamčiti da će se naše usluge odvijati bez prekida ili da takvi problemi neće na neki drugi način utjecati na njih. Europska Komisija ne preuzima nikakvu odgovornost u vezi s problemima koji nastanu zbog uporabe ovih stranica ili bilo kojih povezanih vanjskih stranica. Ovom se izjavom o ograničenju odgovornosti ne ograničava odgovornost Europske Komisije u slučaju kršenja uvjeta propisanih primjenjivim nacionalnim pravom niti se isključuje njezina odgovornost u slučajevima u kojima u skladu s tim pravom to nije moguće. + + 65535 + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://ec.europa.eu/tools/lotl/eu-lotl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUlistofthelists + + + EU + + + application/vnd.etsi.tsl+xml + + + + European Commission + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUlistofthelists + + + + + + + + + MIIFMzCCAxugAwIBAgIJAJzqELfj2cWyMA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNVBAYTAkFUMS8wLQYDVQQKDCZSdW5kZnVuayB1bmQgVGVsZWtvbSBSZWd1bGllcnVuZ3MtR21iSDEXMBUGA1UEAwwOUlRSIFNlcnZpY2VzIDQwHhcNMTcwMTE5MTc1ODA4WhcNMjEwMTE5MTc1ODA4WjBXMQswCQYDVQQGEwJBVDEvMC0GA1UECgwmUnVuZGZ1bmsgdW5kIFRlbGVrb20gUmVndWxpZXJ1bmdzLUdtYkgxFzAVBgNVBAMMDlRydXN0ZWQgTGlzdCA2MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyVv8Q9Sw5HlU5/g4S0vOIH4FT0HOqLob9Loj8LA0DXhCUFxZUbZxl3zltAc72SdIUhOs16W7htYo6TKY1cRJqvpt6qm5l8P+B6o0Gt2evy1vgt/kvRvRVjk2Qsd9H1d2nIiyRr5z3ac3d2kiX0sIe2I02GHsJqEqahBdR2b5O8bMi5CVxh1ZgwQo+AieYtrrnBI9otyUiTyWZvk9DmOb28bdLGqOKArtub90EunCezUhKCOYmIEgAphS0KEE4SOURFreOGeJppd9OvkCN4mQkWdPxOoPpsAZmUu1KrwlAPNbpZR41MSNGNo3k7Y3jMxSLB2tP9nOcZI8HDFg+sy/4QIDAQABo4IBADCB/TAfBgNVHSMEGDAWgBQy0CUUAY3m62y+7e/kHp75C2vPCDAdBgNVHQ4EFgQUD4/pY33/ttXb8YCK17ovsM9AXHMwDgYDVR0PAQH/BAQDAgeAMBQGA1UdIAQNMAswCQYHKigADwABAjAJBgNVHRMEAjAAMBEGA1UdJQQKMAgGBgQAkTcDADA1BgNVHR8ELjAsMCqgKKAmhiRodHRwczovL3d3dy5zaWduYXR1ci5ydHIuYXQvcnRyNC5jcmwwQAYIKwYBBQUHAQEENDAyMDAGCCsGAQUFBzAChiRodHRwczovL3d3dy5zaWduYXR1ci5ydHIuYXQvcnRyNC5jZXIwDQYJKoZIhvcNAQELBQADggIBAJgl406ah6pLX2efheBaENNLKzwvAPyevk+Ohpx0qbL3S4Rpq5a8XqWkCnl2H7Cx6faED3xwQmYv62w3X5/wuqVkBnuyYO/L5lPvAK0mYjvATf86SHzf/yR1SxcFsbydVPPhTCvRagjbejgtnenfMSTIOam96opZh1FL1e2yWL9tZFn7DUHnVwN+d/LKjSIlkZVb4p7htGKOzps5Wc/ZkBUcgpWZ3zvLlIxAR0mlmShgI1MAkP9vzTvO94MUpoxpnZTN6le3svNv0D9zrkncqDtokr+JpAeYmqwy3sRxd3g5qmAAhuYfOr2o9rMVzqIVn7DmT2u454ZrDletEoVx6n1Go8kBqevslZi/U/udapXm2BVsX7HufG3PL7kDm9rY+npAjk2sCL6K0Mo4y+BiVe81ZGELplGFQdqEbC+Um19hVtZaUqw6pa9GGeYJJESimyKQzmE/5RuSwFPsOehK1MSqbEIczX9d+SM/HH5A8STMydI2Fx5y9r5v7sTRPVSLLU+s+WRuMpObM+Xi00iF4CihSwnWVTpFtVQlaBHHK9muUHGuW9fo9qoExFS1nbUvbbjoa7A+qIhtDrrx6QmD9paCyjt18+TaxmTEzOYzOR6DPIY7LG4bMKk7L6ocF+HXjXiAovMig3cV9RF4Pg2dl5wOBItLVRUYIZlxBolo80AP + + + + + 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 + + + + + MIIF5TCCA82gAwIBAgIJAJzqELfj2cW6MA0GCSqGSIb3DQEBCwUAMFcxCzAJBgNVBAYTAkFUMS8wLQYDVQQKDCZSdW5kZnVuayB1bmQgVGVsZWtvbSBSZWd1bGllcnVuZ3MtR21iSDEXMBUGA1UEAwwOUlRSIFNlcnZpY2VzIDQwHhcNMjAxMDIxMTI0MDQ0WhcNMjUxMDIxMTI0MDQ0WjCBiDELMAkGA1UEBhMCQVQxLzAtBgNVBAoMJlJ1bmRmdW5rIHVuZCBUZWxla29tIFJlZ3VsaWVydW5ncy1HbWJIMS8wLQYDVQQLDCZGYWNoYmVyZWljaCBUZWxla29tbXVuaWthdGlvbiB1bmQgUG9zdDEXMBUGA1UEAwwOVHJ1c3RlZCBMaXN0IDgwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQCln0ROEnxEmVriPcgrNpyBkAfXPmMDJbZMOsk6kHTG7LiN1VYJ6t8QjgzKkw8JZaNfwqQQ90mtnTG158Tb42XLt2Vx05W1ygEET0r2v5gQZLFQI6yiUTFnI2a9MRrEgO/wWiJ/ynrW/I6fEojjkcgsNEk/xZPvjEfrD20s9KU413QbvVmgE5wgdZqd+TpuORi/71klGZZkS/93+Lag8evXUkrJHKSFI9Ebr55MIay5uQUtktTqWSu7UX8lSisbxZi+MB0de519lnSKeP3slR7wJtK3OJJgRbbk3/aXTwXMHVAakb+9G8O5Dze9y+WQhOhR0cVcZWwDZmply0EEQvhjuXuXRP05rKF7R0cfsNbvEgNF2QnPWwFFBxzVn0vDDUMJhUt6Qih506IGns/wnYjpidIA0rUFG1173xLm92DTkWabXX+JQgFHop08R54ihZ9+RGG07pm38ZtTIHSAcEKV+oygJ9gDCzvN/HtV6GRmLIPoNKtwrUHFE3dlu1R2o4cCAwEAAaOCAQAwgf0wHwYDVR0jBBgwFoAUMtAlFAGN5utsvu3v5B6e+QtrzwgwHQYDVR0OBBYEFFR1UKDeW4NLF9S7bKCZWTMrUVxWMA4GA1UdDwEB/wQEAwIHgDAUBgNVHSAEDTALMAkGByooAA8AAQIwCQYDVR0TBAIwADARBgNVHSUECjAIBgYEAJE3AwAwNQYDVR0fBC4wLDAqoCigJoYkaHR0cHM6Ly93d3cuc2lnbmF0dXIucnRyLmF0L3J0cjQuY3JsMEAGCCsGAQUFBwEBBDQwMjAwBggrBgEFBQcwAoYkaHR0cHM6Ly93d3cuc2lnbmF0dXIucnRyLmF0L3J0cjQuY2VyMA0GCSqGSIb3DQEBCwUAA4ICAQCEwpo3NfiWr0/SaXLuYKVdDQJWqkfC7XbCjB9RCd0zLLGhUa9qqoe/q28aqTZpSDtGud5hGt6qag9Uoc85gau9FsYfaqf6BH+ZckHQuQLzqH3KGC5hbvRj1j8eV/T8PfLsMMrEuUFGojbVhHlWMOJBtzJu7NvbvqHAfowNr9nm9qOJ0xk5JPOzMU1rp3F3gsLTzD/qjCCZMY5Ej8pwRp1RZIwJVOeW7yPrtrIOz0ynnyCCMKZbs6hTgGtW9oVW70yV5M+IRinnTwYylXvWt7Dn/LVGZNi9vbgETPK+KUppb/DAO8VorKDPLefcP2yHN4GBxJRrDZxMHU3Xjzk1nhCHSaZcrEEbz7HQXRFAc0fyI4KXhe62E8ibZRsCSwpsu5jmll5zK9BZdkoStNGIdMRAo0btaonhi/Z/AwE01QJ6oR4mP3tnmlRfRZEYDMOqYjTbRxR7Y8C6io/MqPODOvzDd+7RvcPw+IO0EkW96XzZVyFuPKRAc0fx04RhSZqNOK8NIrRWULEefI8rfm/BOlQnaA5Zt+AA/013hHB9jKUxJsx+Im5/7Qks1zdy9XkPnNzPx6hrs4yXpDB/OdSvvVnZ+nsawx4Tapa8Kat9lLwCyEODdhzT0/Rsr2XD+VPNNGrkaX/RUKtQJAsBqyB93yZtZstYS9Ni0XPezrgF8Srv+g== + + + + + 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 + + + + + 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 + + + + https://www.signatur.rtr.at/vertrauensliste.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + AT + + + application/vnd.etsi.tsl+xml + + + + Rundfunk und Telekom Regulierungs-GmbH + Rundfunk und Telekom Regulierungs-GmbH + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/AT + + + + + + + + + MIID3zCCAsegAwIBAgIJAOOTbJMmowFCMA0GCSqGSIb3DQEBBQUAMIGHMS0wKwYDVQQDEyRCZWxnaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxSTBHBgNVBAoTQEZQUyBFY29ub215LCBTTUVzLCBTZWxmLWVtcGxveWVkIGFuZCBFbmVyZ3kgLSBRdWFsaXR5IGFuZCBTYWZldHkxCzAJBgNVBAYTAkJFMB4XDTE0MDIxOTEzMzcxNVoXDTI0MDIxNzEzMzcxNVowgYcxLTArBgNVBAMTJEJlbGdpYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjFJMEcGA1UEChNARlBTIEVjb25vbXksIFNNRXMsIFNlbGYtZW1wbG95ZWQgYW5kIEVuZXJneSAtIFF1YWxpdHkgYW5kIFNhZmV0eTELMAkGA1UEBhMCQkUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAgEFkoDPTYDvGk+/IPnGSPm58NRE7mpzLHk8lxpYnTAtbMhn7FWru9GlNi+blYYNOEmzN2E5KO9+7AAAMmx2x8zmEMwc3oUQ7E0WN5Gl+Y+7n6NtX50D/4Sbw4IjVvwwRRru8Coj5vq5Hz3JKTgft8teEpwb5vSFZh6+o9irdX342RJU4AtG78sxZvzIqpa3WsddMf5XDyjnGK3dRgkDuOaBxWEexuUiN4LvO+MacwoaxEqLhEZ6TALGWS2WmNEW3OlUdf7nc0Tz/lnyQsuFn01c4pg56hjyxLtpjyHwNwbTDx+cjBpBveOT9Nb6UfKFHknC5AfrIOWnFLXUmyKD/AgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgbAMB0GA1UdDgQWBBRf745pXfv0l1rxBwgOUhlQqteQUTARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQEFBQADggEBAG8j1gOIKEKTd904EepYs1MioBErjXxkAN2zvaZevh3awkB6cGeQUnmDz3ve4ZCJSB4MZ138EkUi2eobXaPyaLv01vl6sM6eUj6QhwNvfGXHP99AOHG8ZyH4IkJgB+8jImhg2danj4VcAosGtvTknYtZ2K+GhRevgAnoryhJ7A7jszwWzaahFwTnunymlBXlrwG9KyBSkg4IhWgc+IgYUgA7rpOZ6zXFPTJQJphiRg7pQECnV1Fvw9ediMGhBnNL3tE/5IKIug2XoJ3Mlh9lho6c8YAhyp2Q16inCLDJksZc1qUqRHo9lmwWnGANWfZvQWRJS0LJvrF7LSL5H/Y4yZo= + + + + + MIID3zCCAsegAwIBAgIJAJH6V+OXuB7aMA0GCSqGSIb3DQEBBQUAMIGHMS0wKwYDVQQDEyRCZWxnaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxSTBHBgNVBAoTQEZQUyBFY29ub215LCBTTUVzLCBTZWxmLWVtcGxveWVkIGFuZCBFbmVyZ3kgLSBRdWFsaXR5IGFuZCBTYWZldHkxCzAJBgNVBAYTAkJFMB4XDTE0MDIxOTEzMzc0MFoXDTI0MTAxNDEzMzc0MFowgYcxLTArBgNVBAMTJEJlbGdpYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjFJMEcGA1UEChNARlBTIEVjb25vbXksIFNNRXMsIFNlbGYtZW1wbG95ZWQgYW5kIEVuZXJneSAtIFF1YWxpdHkgYW5kIFNhZmV0eTELMAkGA1UEBhMCQkUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAgEFkoDPTYDvGk+/IPnGSPm58NRE7mpzLHk8lxpYnTAtbMhn7FWru9GlNi+blYYNOEmzN2E5KO9+7AAAMmx2x8zmEMwc3oUQ7E0WN5Gl+Y+7n6NtX50D/4Sbw4IjVvwwRRru8Coj5vq5Hz3JKTgft8teEpwb5vSFZh6+o9irdX342RJU4AtG78sxZvzIqpa3WsddMf5XDyjnGK3dRgkDuOaBxWEexuUiN4LvO+MacwoaxEqLhEZ6TALGWS2WmNEW3OlUdf7nc0Tz/lnyQsuFn01c4pg56hjyxLtpjyHwNwbTDx+cjBpBveOT9Nb6UfKFHknC5AfrIOWnFLXUmyKD/AgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgbAMB0GA1UdDgQWBBRf745pXfv0l1rxBwgOUhlQqteQUTARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQEFBQADggEBABSri/BFtWHsvDgFri/fPFXJaQ9a5U1HgfOrg0pcVacnC2ezhZ3Ita1d+nWlaHfUBx2L7pp41G23TZE9Efcb/8RPuYDDcIv2TSKV/hIxthk+IP6avZ6cEuWL3iXhqusRM313QgH8G67EPDmTy9hX0t/3KnBQZ6gmb9SpTnG44pQ8LOfLvpzaT2Z1etBsXp0JED7P0OPJq459S3huIYoM3NTNaU8dLGAYJUR7D2fcvDySvt8xIjO7HtzHer79Uq4bNn8uRRHgKJ2LMBK0LvoVBX0PekQFSXi06xpPA9SjmozZ76dW0fK7uPUOFoXB9LtsZCFsMRjTL9+KhPyhSam2iy8= + + + + + MIID3zCCAsegAwIBAgIJAK7RpgGHETKPMA0GCSqGSIb3DQEBBQUAMIGHMS0wKwYDVQQDEyRCZWxnaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxSTBHBgNVBAoTQEZQUyBFY29ub215LCBTTUVzLCBTZWxmLWVtcGxveWVkIGFuZCBFbmVyZ3kgLSBRdWFsaXR5IGFuZCBTYWZldHkxCzAJBgNVBAYTAkJFMB4XDTE0MDIxOTEzMzc1MloXDTI1MDIxMTEzMzc1MlowgYcxLTArBgNVBAMTJEJlbGdpYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjFJMEcGA1UEChNARlBTIEVjb25vbXksIFNNRXMsIFNlbGYtZW1wbG95ZWQgYW5kIEVuZXJneSAtIFF1YWxpdHkgYW5kIFNhZmV0eTELMAkGA1UEBhMCQkUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAgEFkoDPTYDvGk+/IPnGSPm58NRE7mpzLHk8lxpYnTAtbMhn7FWru9GlNi+blYYNOEmzN2E5KO9+7AAAMmx2x8zmEMwc3oUQ7E0WN5Gl+Y+7n6NtX50D/4Sbw4IjVvwwRRru8Coj5vq5Hz3JKTgft8teEpwb5vSFZh6+o9irdX342RJU4AtG78sxZvzIqpa3WsddMf5XDyjnGK3dRgkDuOaBxWEexuUiN4LvO+MacwoaxEqLhEZ6TALGWS2WmNEW3OlUdf7nc0Tz/lnyQsuFn01c4pg56hjyxLtpjyHwNwbTDx+cjBpBveOT9Nb6UfKFHknC5AfrIOWnFLXUmyKD/AgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgbAMB0GA1UdDgQWBBRf745pXfv0l1rxBwgOUhlQqteQUTARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQEFBQADggEBABabI8rU/pW4uiTHk47X838qntx6FJ5iDCs+iaED142+yju/wQVU4J8rjS4UqsdO8wOM4sfyLjMLRRsK60saZ5o2u+tLIj0QrFRytTD1WIuPZxpBjQU8Zj/+aLkr4bQmyqgJ4XzJZ9BMvi3Yv18jQxJSjvGpXaWpUNLNnhENTuzKv8f/0vBn2Inmpg7cwgj2q8qhZ/3r1ZmHETSDmEdjV4ovYruAKX58jwwnRdgacTtgQpB88+zZDtAp3FVJxR9nefCdvjV2nuN++UgA2v8d2u9c8c7ObGd7dL6O9rQCfvBWbw6/h9nkXSJSAjKXS1uvnABtq3fQabHwxNc8rIQPkLk= + + + + + MIID3zCCAsegAwIBAgIJAOv7FV6q0Or/MA0GCSqGSIb3DQEBBQUAMIGHMS0wKwYDVQQDEyRCZWxnaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxSTBHBgNVBAoTQEZQUyBFY29ub215LCBTTUVzLCBTZWxmLWVtcGxveWVkIGFuZCBFbmVyZ3kgLSBRdWFsaXR5IGFuZCBTYWZldHkxCzAJBgNVBAYTAkJFMB4XDTE0MDIxOTEzMzgwNFoXDTI1MDYxMTEzMzgwNFowgYcxLTArBgNVBAMTJEJlbGdpYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjFJMEcGA1UEChNARlBTIEVjb25vbXksIFNNRXMsIFNlbGYtZW1wbG95ZWQgYW5kIEVuZXJneSAtIFF1YWxpdHkgYW5kIFNhZmV0eTELMAkGA1UEBhMCQkUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDAgEFkoDPTYDvGk+/IPnGSPm58NRE7mpzLHk8lxpYnTAtbMhn7FWru9GlNi+blYYNOEmzN2E5KO9+7AAAMmx2x8zmEMwc3oUQ7E0WN5Gl+Y+7n6NtX50D/4Sbw4IjVvwwRRru8Coj5vq5Hz3JKTgft8teEpwb5vSFZh6+o9irdX342RJU4AtG78sxZvzIqpa3WsddMf5XDyjnGK3dRgkDuOaBxWEexuUiN4LvO+MacwoaxEqLhEZ6TALGWS2WmNEW3OlUdf7nc0Tz/lnyQsuFn01c4pg56hjyxLtpjyHwNwbTDx+cjBpBveOT9Nb6UfKFHknC5AfrIOWnFLXUmyKD/AgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgbAMB0GA1UdDgQWBBRf745pXfv0l1rxBwgOUhlQqteQUTARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQEFBQADggEBAJQt17IzKeqnxakdgysT1FlymocZUUHGhfbQAfr4OEm48LMoN4M5ZeeRMVIwk4jODURuhawtKJ3hRdGB+zTzIMLheOmAGGRDUNrDwctpn8G+RqEFjlgc5yi1ICHBZJrvyud7cPwz8AwMtV+K1iFmbEWqsGASZ96J9uilJJ+RkPcV3Olwtgi3+IxOxHfhmq0PCdRk1k8+c7frdT935Z8SfFgnaPy4RFg2eKdvC2qsvsF3J19eP/BKlGdVVe44yTB3UCE3KSLiySvgM/JXIQN5VE+lGPeURKnoXsW5E71IdUEi30Ptd0YBxTjEairZKyzhgGbZEnBUWSkn6n9uZ5Ai2lo= + + + + + MIIFeDCCBP6gAwIBAgIMWC5ThUy0RpptTp0uMAoGCCqGSM49BAMDMH8xCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMTowOAYDVQQDEzFHbG9iYWxTaWduIEdDQyBFNDUgUXVhbGlmaWVkIFFTQ0QgU2lnbmluZyBDQSAyMDIwMRkwFwYDVQRhExBOVFJCRS0wNDU5MTM0MjU2MB4XDTI1MDcyMjE1MzUxOFoXDTI3MDcyMzE1MzUxOFowggEHMQswCQYDVQQGEwJCRTEnMCUGA1UECBMeQnJ1c3NlbHMgSG9vZmRzdGVkZWxpamsgR2V3ZXN0MRwwGgYDVQQHExNTaW50LUpvb3N0LXRlbi1Ob2RlMUkwRwYDVQQKE0BGZWRlcmFsZSBPdmVyaGVpZHNkaWVuc3QgRWNvbm9taWUsIEsuTS5PLCBNaWRkZW5zdGFuZCBlbiBFbmVyZ2llMUkwRwYDVQQDE0BGZWRlcmFsZSBPdmVyaGVpZHNkaWVuc3QgRWNvbm9taWUsIEsuTS5PLCBNaWRkZW5zdGFuZCBlbiBFbmVyZ2llMRswGQYDVQRhExJOVFJCRS0wMzE0LjU5NS4zNDgwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCw1ThDEoFFZJhP2qJPJDyxzuL/G7AghC0dmWMwMKAACSgXuGhLnsNvLeaxe6nc/eVcDokU0bOdSD3c7d8RG7hv5OtQ22X2EH6Pve1IT1Lgg3+xfmBLrmHi/UGik75KrAN7ifuhzqFEgDOqku8ZSO4+PDs9HZg6X4phillTWIJ+H3rrm8Zb/msgKjdKgZZag9Ql0hzdoJwzkCXVqJrV32d2c5e2Z3t8ExAjlXcfjIdfW8ONOwIqCe/SefiXoabygmUhc+CzJ6b8ylahQCkIpMaqtAZoUQGeNXSBykUHZddpXNbikM7uwnAiCEUAa8jEa/YWG2CJs7swF7MNMG+yaaXpAgMBAAGjggIJMIICBTAOBgNVHQ8BAf8EBAMCBkAwgaMGCCsGAQUFBwEBBIGWMIGTME4GCCsGAQUFBzAChkJodHRwOi8vc2VjdXJlLmdsb2JhbHNpZ24uY29tL2NhY2VydC9nc2djY2U0NXF1YWxxc2Nkc2lnbmNhMjAyMC5jcnQwQQYIKwYBBQUHMAGGNWh0dHA6Ly9vY3NwLmdsb2JhbHNpZ24uY29tL2dzZ2NjZTQ1cXVhbHFzY2RzaWduY2EyMDIwMFkGA1UdIARSMFAwQwYLKwYBBAGgMgEoJAIwNDAyBggrBgEFBQcCARYmaHR0cHM6Ly93d3cuZ2xvYmFsc2lnbi5jb20vcmVwb3NpdG9yeS8wCQYHBACL7EABAzBJBgNVHR8EQjBAMD6gPKA6hjhodHRwOi8vY3JsLmdsb2JhbHNpZ24uY29tL2dzZ2NjZTQ1cXVhbHFzY2RzaWduY2EyMDIwLmNybDA3BggrBgEFBQcBAwQrMCkwCAYGBACORgEBMAgGBgQAjkYBBDATBgYEAI5GAQYwCQYHBACORgEGAjAgBgNVHSUEGTAXBgkqhkiG9y8BAQUGCisGAQQBgjcKAwwwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBS1ixC9qo9vveNITthfKIMXFhc9OzAdBgNVHQ4EFgQUVTXDcVGqVUX3iJr2LRjemG+LzfkwCgYIKoZIzj0EAwMDaAAwZQIwWMjqbDmwwt5EGM5D/X09QIAQwXjfbTKmF+3w33aGdVTV8DDG7Gtku5EmtYQQU4LOAjEA3M3qbx5FFEXGFaNuGkLWbpOHVepkI84zZg5q+cRsdfhwGw7s98XZ7ESDnFvsC4YC + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.belgium.be/tsl-be-v6.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + BE + + + application/vnd.etsi.tsl+xml + + + + FPS Economy, SMEs, Self-employed and Energy - Quality and Safety + SPF Economie, PME, Classes moyennes et Energie - Qualité et Sécurité + FOD Economie, KMO, Middenstand en Energie - Kwaliteit en Veiligheid + FÖD Wirtschaft, KMU, Mittelstand und Energie - Qualität und Sicherheit + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/BE + + + + + + + + + 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 + + + + + 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 + + + + https://crc.bg/files/_en/TSL_BG.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + BG + + + application/pdf + + + + Communications Regulation Commission + Комисия за регулиране на съобщенията + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/BG + + + + + + + + + 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 + + + + + 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 + + + + https://crc.bg/files/_en/TSL_BG.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + BG + + + application/vnd.etsi.tsl+xml + + + + Communications Regulation Commission + Комисия за регулиране на съобщенията + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/BG + + + + + + + + + MIIDkTCCAnmgAwIBAgIFEkAyZ6kwDQYJKoZIhvcNAQELBQAwWDELMAkGA1UEBhMCQ1kxMDAuBgNVBAoMJ0RlcGFydG1lbnQgb2YgRWxlY3Ryb25pYyBDb21tdW5pY2F0aW9uczEXMBUGA1UEAwwOQ1ktVFNMIFNpZ25lcjEwHhcNMTcxMjAxMDAwMDAwWhcNMjcxMjAxMDAwMDAwWjBYMQswCQYDVQQGEwJDWTEwMC4GA1UECgwnRGVwYXJ0bWVudCBvZiBFbGVjdHJvbmljIENvbW11bmljYXRpb25zMRcwFQYDVQQDDA5DWS1UU0wgU2lnbmVyMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKAsRMYRj0v937oGqxRQrjvWBFncZ+jEq/qyUxgiQB0DGWnOEN9QbtvdIu/swVSCh3FZc7vrvI2aTt0NDQ2kZ8ohBpcj+qQb4xUFU5PXhUdIiGsqGO/+0hYeteJZyhHZ1VxL97U0LzmqkmfYumNmJUdDOoqfmzkatHrORvooSlK+SYhXHTrCxXEU0e3xIwnlXcyaVXRBbDdFsGY3p5QrhTBQ5Cd+FxZMhHLhxnUetPnqN9GOJXgghZAy+72c4zmc7X8gshaxbvO7MEvrBgdbaZcjHod7XiHowzCTxLFjDR9eHXrLvmukYcY9qeb5ieJ37VXf9JUbO9q+aFQu5wJ61Z8CAwEAAaNiMGAwHQYDVR0OBBYEFDPKoJc8X/T59hCvhxlDqw2JXj1uMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAINBgvYZfI1L6iY0i1OnVoQR4Nje/FuCzW9tppUCC2h9T9x9sClph6o8hceaiBUDdobX9/BIxc15o59q7wbmyGtYnNpZG8nctj/90uciXvUdOCA7PQeX5/cMUVU/Yscg+Pv1ydNyu/7tZtdDfKDyc+Lux9CDGpvYMDDRqX048NsYTB4shry0a7EzhOyD8jIYjY2xU7AYIvGQI1w/OZ2wqEAM7KhhEHz915wdhkv9DBb/CB14mONa1gMWTL27e7GnXZ+mWZghF1HyDjbG3Pr6jFzEgvxMTkGGLpvLOFm7ULwqYbP+ORd7l6exZ+XvzoN5ilPRZmnx/6eHdhutre/BqmE= + + + + + MIIDkTCCAnmgAwIBAgIFEm38MY8wDQYJKoZIhvcNAQELBQAwWDELMAkGA1UEBhMCQ1kxMDAuBgNVBAoMJ0RlcGFydG1lbnQgb2YgRWxlY3Ryb25pYyBDb21tdW5pY2F0aW9uczEXMBUGA1UEAwwOQ1ktVFNMIFNpZ25lcjIwHhcNMTgwNTAxMDAwMDAwWhcNMjgwNTAxMDAwMDAwWjBYMQswCQYDVQQGEwJDWTEwMC4GA1UECgwnRGVwYXJ0bWVudCBvZiBFbGVjdHJvbmljIENvbW11bmljYXRpb25zMRcwFQYDVQQDDA5DWS1UU0wgU2lnbmVyMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALNtGgaAVmMYd5N0LDtMTtNGwZCga3LWsDfJ2ft1S30pU3+CSUOLHxl44fp9xPf6xrbn8g9OVt52Ey1TsEXWjmOtcXrnyDoEzMBpJiDUyXD4LabfN+0POXH/5wpmuoEohEb39SN4HUXsIKjU9WFr+MA8T77g7UPIt7ymZ6q/LuF/cdf2vVzD9xhkt9+oZjuh4NNtUeGBbrjaTMFfeIvKeOJd2Ar/rytDLeCi+ikdyt7KzE8RxY/H5jlUikh/kGrDcDzp6Q2jZrukCUx60ZAmoD74D8CqNyfYjBZ9GX3wg/DhfyWrbw5bHIa1CMVq+qMV2TbhWupJAVewyXZDZLX7LgsCAwEAAaNiMGAwHQYDVR0OBBYEFJoW0el/Y7woUa3DpsmhC3hOI2HTMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAImG6p0MDaJLK5oCGbqF/6mheRG2g3UBe+NqjOb+jjvuSWmcTHBgHE03fctR51zlCvup9/y2Y3b/ga8XFKfI1lF8jVzl74h0WXYg/OmgQ7MaJK7T1UevPZatx9+yG8Mh4fMaKWLzpRq2522KbXkVGpWweYp5RNXDcFsJV2joenq1g3FfFX9LK43V6EUzCJ+8wb7nwzOSqIe4lQGrqCMUJoBD+uSjKvbKbrFRR01ZJjM6UjC77x9SePGbyZhoBDOkizjMCDYdc8HThGQdQPRT3104BTQtUnTqR+IzXpv/1AsStmvvLYzFmE+SnLvspUmGW/Ki+8lSqI4wNybBnnYOXbg= + + + + https://dec.dmrid.gov.cy/dmrid/dec/ws_dec.nsf/all/5064247FF4FC3DCCC2258506002EEA17/$file/TSL-CY-sign.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + CY + + + application/vnd.etsi.tsl+xml + + + + Department of Electronic Communications + Τμήμα Ηλεκτρονικών Επικοινωνιών + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/CY + + + + + + + + + MIIF0zCCA7ugAwIBAgIIWJYC72/hm6gwDQYJKoZIhvcNAQENBQAwejELMAkGA1UEBhMCQ1oxDzANBgNVBAcTBlByYWd1ZTEsMCoGA1UECgwjRGlnaXTDoWxuw60gYSBpbmZvcm1hxI1uw60gYWdlbnR1cmExLDAqBgNVBAMMI0RpZ2l0w6FsbsOtIGEgaW5mb3JtYcSNbsOtIGFnZW50dXJhMB4XDTIzMDMxNzE5NDEwMFoXDTI2MDMxNzE5NDEwMFowejELMAkGA1UEBhMCQ1oxDzANBgNVBAcTBlByYWd1ZTEsMCoGA1UECgwjRGlnaXTDoWxuw60gYSBpbmZvcm1hxI1uw60gYWdlbnR1cmExLDAqBgNVBAMMI0RpZ2l0w6FsbsOtIGEgaW5mb3JtYcSNbsOtIGFnZW50dXJhMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzgjT/fKm7K1DjMjMmPgNfFQ5EZUXA/NgccTA40jlcqb6fY1tVsrodsbH+xyKnULEU2FBlmjOw4gWC88y4ztIjnpcG3wLcFJ6j2p/y/R10rs6AipZHxzlKGJLmril43/GS8IRQXwi9N0NzuzCIV0tJ543kWBuYwQtRrCzYY+7RH2kB96dw1BfqghL1TXSSApZeWYCW0D5AEGePhSJjtMxZDxmncCEX+7TgYqI8MqF6XttXFZxDkBfWiXvsJUbdcWKI/+zUe+PPqvkxvEnuBzcWq3iuAMbhrYBLGewylChYsLMIIvgMCvGi7jvNO5Y/CsqHfSSS2qMDh70SIESSRxbPcCaSV9QDBDUC3vv9S5xzVjPiRJ7h8htiBhagcwl3QqpAl0MYAadHwD3+CbOpSk9qZF5qnpsevs0NK+yQ1FXDINJ6+xTJ5AvNCFgF1etrclkXLn6LBiZGxA5lYn4YwgJ99OWBE6Vxg1YYlbraHU+LWXnzzSpXGlFUTa6OuzsIFJ19vh2jAZ4Z0vebdiFdLFQeqlRETC7nHvvFasT9gbefuWcRvUFvCp6EXT282EZ/47v69yr0TGCS6U41Djjsq3YQBpRcnOqXZRkuP9uRW77Q60qsQ5xQ5yVie3U4lAWyhye1T+xrVTPTrkjGM7LvcE75pcNu5D6Jh4OQ+c0me26ysECAwEAAaNdMFswCQYDVR0TBAIwADAdBgNVHQ4EFgQUAGMMk3xkJNXNQg3UtIJvfe59rP8wHwYDVR0jBBgwFoAUAGMMk3xkJNXNQg3UtIJvfe59rP8wDgYDVR0PAQH/BAQDAgbAMA0GCSqGSIb3DQEBDQUAA4ICAQA4Ua1xWnQ2HLWFj/+pq6fE+jaCc7ny+461YvhVvIjoCUZ+PMmj7W07hC2cMgI+NXqosIGl/cCuPCoCo8MCEDJPm2BDe8empzJkM4Nc0+3NXwsrNHmRG+UI6lhfbGU/xWrOTdT9RYoHHg3fK0aBRop6yrHAE/ayflTnkXLEjuDc0//D+F3WmVxQ8GWubYmSUPJGYEUIdUSfwl5fKVrtyg5/lZ9uNlRhR+RrBjn5ifN1WMmJCPJwFMUamRhM86AGNNuDuTj5z4dSvTdRWs8VnG2CObtSbt4BDq8nMGRH7flIgQGaip0s4r5QJ7rjDzSwEUwrwEsEDQXIBB7Qxb30zwxqMKzApXBXobm6rhLCClqbvxOQV+/yiknENTcQXd5Bsbugy05Nb/2yBAleGy3gqzpO8Bj5PZ03ecPh6zEW8MdYOVw2VC4Uodw03G8bjDWUTAzMEXjdoXOiEssx1/KAs6w+EcEY4shNl5O5jLKMG92G5OFXPi94M+u/H/iZgrcRraF5vqu6AvefAlLspmm7QSRTsajAorXNj8w2aMyEB02YcxLc5zduIHyJrkPHnzeAIfplEXj9gQBs/eyZRZ/P7YmQnlDkim0he6/KPsuPKd0TP7uiSguT1GQLYmgKyjfm3mRnubotER59VOz57CY+31BSVQdvbiFy27jCyZb7daMgfg== + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.gov.cz/publ/TSL_CZ.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + CZ + + + application/pdf + + + + Digital and Information Agency + Digitální a informační agentura + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/CZ + + + + + + + + + MIIF0zCCA7ugAwIBAgIIWJYC72/hm6gwDQYJKoZIhvcNAQENBQAwejELMAkGA1UEBhMCQ1oxDzANBgNVBAcTBlByYWd1ZTEsMCoGA1UECgwjRGlnaXTDoWxuw60gYSBpbmZvcm1hxI1uw60gYWdlbnR1cmExLDAqBgNVBAMMI0RpZ2l0w6FsbsOtIGEgaW5mb3JtYcSNbsOtIGFnZW50dXJhMB4XDTIzMDMxNzE5NDEwMFoXDTI2MDMxNzE5NDEwMFowejELMAkGA1UEBhMCQ1oxDzANBgNVBAcTBlByYWd1ZTEsMCoGA1UECgwjRGlnaXTDoWxuw60gYSBpbmZvcm1hxI1uw60gYWdlbnR1cmExLDAqBgNVBAMMI0RpZ2l0w6FsbsOtIGEgaW5mb3JtYcSNbsOtIGFnZW50dXJhMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAzgjT/fKm7K1DjMjMmPgNfFQ5EZUXA/NgccTA40jlcqb6fY1tVsrodsbH+xyKnULEU2FBlmjOw4gWC88y4ztIjnpcG3wLcFJ6j2p/y/R10rs6AipZHxzlKGJLmril43/GS8IRQXwi9N0NzuzCIV0tJ543kWBuYwQtRrCzYY+7RH2kB96dw1BfqghL1TXSSApZeWYCW0D5AEGePhSJjtMxZDxmncCEX+7TgYqI8MqF6XttXFZxDkBfWiXvsJUbdcWKI/+zUe+PPqvkxvEnuBzcWq3iuAMbhrYBLGewylChYsLMIIvgMCvGi7jvNO5Y/CsqHfSSS2qMDh70SIESSRxbPcCaSV9QDBDUC3vv9S5xzVjPiRJ7h8htiBhagcwl3QqpAl0MYAadHwD3+CbOpSk9qZF5qnpsevs0NK+yQ1FXDINJ6+xTJ5AvNCFgF1etrclkXLn6LBiZGxA5lYn4YwgJ99OWBE6Vxg1YYlbraHU+LWXnzzSpXGlFUTa6OuzsIFJ19vh2jAZ4Z0vebdiFdLFQeqlRETC7nHvvFasT9gbefuWcRvUFvCp6EXT282EZ/47v69yr0TGCS6U41Djjsq3YQBpRcnOqXZRkuP9uRW77Q60qsQ5xQ5yVie3U4lAWyhye1T+xrVTPTrkjGM7LvcE75pcNu5D6Jh4OQ+c0me26ysECAwEAAaNdMFswCQYDVR0TBAIwADAdBgNVHQ4EFgQUAGMMk3xkJNXNQg3UtIJvfe59rP8wHwYDVR0jBBgwFoAUAGMMk3xkJNXNQg3UtIJvfe59rP8wDgYDVR0PAQH/BAQDAgbAMA0GCSqGSIb3DQEBDQUAA4ICAQA4Ua1xWnQ2HLWFj/+pq6fE+jaCc7ny+461YvhVvIjoCUZ+PMmj7W07hC2cMgI+NXqosIGl/cCuPCoCo8MCEDJPm2BDe8empzJkM4Nc0+3NXwsrNHmRG+UI6lhfbGU/xWrOTdT9RYoHHg3fK0aBRop6yrHAE/ayflTnkXLEjuDc0//D+F3WmVxQ8GWubYmSUPJGYEUIdUSfwl5fKVrtyg5/lZ9uNlRhR+RrBjn5ifN1WMmJCPJwFMUamRhM86AGNNuDuTj5z4dSvTdRWs8VnG2CObtSbt4BDq8nMGRH7flIgQGaip0s4r5QJ7rjDzSwEUwrwEsEDQXIBB7Qxb30zwxqMKzApXBXobm6rhLCClqbvxOQV+/yiknENTcQXd5Bsbugy05Nb/2yBAleGy3gqzpO8Bj5PZ03ecPh6zEW8MdYOVw2VC4Uodw03G8bjDWUTAzMEXjdoXOiEssx1/KAs6w+EcEY4shNl5O5jLKMG92G5OFXPi94M+u/H/iZgrcRraF5vqu6AvefAlLspmm7QSRTsajAorXNj8w2aMyEB02YcxLc5zduIHyJrkPHnzeAIfplEXj9gQBs/eyZRZ/P7YmQnlDkim0he6/KPsuPKd0TP7uiSguT1GQLYmgKyjfm3mRnubotER59VOz57CY+31BSVQdvbiFy27jCyZb7daMgfg== + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.gov.cz/publ/TSL_CZ.xtsl + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + CZ + + + application/vnd.etsi.tsl+xml + + + + Digital and Information Agency + Digitální a informační agentura + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/CZ + + + + + + + + + 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 + + + + + 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 + + + + https://tl.bundesnetzagentur.de/TL-DE.XML + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + DE + + + application/vnd.etsi.tsl+xml + + + + Federal Network Agency + Bundesnetzagentur + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/DE + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://www.digst.dk/TSLDK_v6pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + DK + + + application/pdf + + + + Digitaliseringsstyrelsen // CVR:34051178 + Danish Agency for Digitisation // CVR:34051178 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/DK + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + MIIGrTCCBOGgAwIBAgIUJjAqWfo4EwCqnJ7O0IShn/Dg7SowQQYJKoZIhvcNAQEKMDSgDzANBglghkgBZQMEAgEFAKEcMBoGCSqGSIb3DQEBCDANBglghkgBZQMEAgEFAKIDAgEgMFYxLTArBgNVBAMMJERlbiBEYW5za2UgU3RhdCBPQ0VTIHVkc3RlZGVuZGUtQ0EgMTEYMBYGA1UECgwPRGVuIERhbnNrZSBTdGF0MQswCQYDVQQGEwJESzAeFw0yNjAyMTgwOTUzMThaFw0yOTAyMTcwOTUzMTdaMIHIMRwwGgYDVQQDDBNKZXNwZXIgRWdlbHVuZCBTaWlnMRcwFQYDVQQqDA5KZXNwZXIgRWdlbHVuZDENMAsGA1UEBAwEU2lpZzE3MDUGA1UEBRMuVUk6REstRTpHOmRlZDUzM2RkLTY4NDgtNGM4ZC05MjMzLWE2NzcyMWQ0MzMyODEhMB8GA1UECgwYRGlnaXRhbGlzZXJpbmdzc3R5cmVsc2VuMRcwFQYDVQRhDA5OVFJESy0zNDA1MTE3ODELMAkGA1UEBhMCREswggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDYZWNi+PH2atgZFnsNb/JUjMaaHbiDTqZuVg6JkwWgtOkep2ivgDdvqZ9otXSM/0PE9gWyAGh7om5Sa0R1w+YRHJ+MLm+akvctGw6tzKZ4erTrw0gFuvh+/9Go6gYUg+hH1+GWp19BvH3M6kToBpSSq/K4t1MnIvVPzgSGtc9i6CquydAErH92c6otVPjz/uYeI7ldqAQ2e7dxKHNv5XOjHDU/XpU3bjTqQdWL6epPzAPEdTCuuBwDEOBW1vYRhOhCSZlX0JA4nXpRb679wRJnpw3Fo8SBbcedFKkmm8ksNpr9qJmGSAH4J4ya34dQ/5e4Vx9knTWgEIuUSOfxeHsQckolH1CquZTz+rM2I5AAGfE7Pov8Dg7TPNcWjqx23z1dFWhaaLEqXeoCUZb2JXiQYsesaCLKRBxV2pPTN0TczEdmPkt4bAELnLvCVSrH/jrm4UPVKxbfHAHD4wWot6U0+xMb1I0Ua9DeOYRNOGbWyQKWoVTpwkGpENHNl1qMFf0CAwEAAaOCAZYwggGSMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUTAHiynO8w744Cjg9NrBcdJx7l7kwcwYIKwYBBQUHAQEEZzBlMD8GCCsGAQUFBzAChjNodHRwOi8vY2ExLmdvdi5kay9vY2VzL2lzc3VpbmcvMS9jYWNlcnQvaXNzdWluZy5jZXIwIgYIKwYBBQUHMAGGFmh0dHA6Ly9jYTEuZ292LmRrL29jc3AwGQYDVR0RBBIwEIEOamVzc2lAZGlnc3QuZGswIgYDVR0gBBswGTAIBgYEAI96AQEwDQYLKoFQgSkBAQECBwEwOwYIKwYBBQUHAQMELzAtMCsGCCsGAQUFBwsCMB8GBwQAi+xJAQEwFIYSaHR0cHM6Ly91aWQuZ292LmRrMEEGA1UdHwQ6MDgwNqA0oDKGMGh0dHA6Ly9jYTEuZ292LmRrL29jZXMvaXNzdWluZy8xL2NybC9pc3N1aW5nLmNybDAdBgNVHQ4EFgQUZfqwopXlyOSJ35/ocoDwRir0aRowDgYDVR0PAQH/BAQDAgXgMEEGCSqGSIb3DQEBCjA0oA8wDQYJYIZIAWUDBAIBBQChHDAaBgkqhkiG9w0BAQgwDQYJYIZIAWUDBAIBBQCiAwIBIAOCAYEAmshbVd2OdwzSsCdBb2qvADvqwQ4lnc98txXYVMF8WfKUUu6UdKCE4sfUvkx/wxyAc18ewPEtAy5m0kuCa5gvU3YQSKQNdfLh3dX+AQjt10YX6XIXKPTHulU4CXh3jbtxWySfj97WOThZQSFBZxkuVzTiaNfX/Z+XEG6kjgUORB2H7FVml2y4tdoqt16I/pkdM91RRiTLZGv8j9yeaI5rMvzJvWUVPbbeX1hP4gZdBTrNEONyhZrWUDa6FtJEy5LPqhzgJF4ddvUOqCfH0c27u7dO0ErVfP5BtDMhKrFubm4Urq59/K2UV0ythdXo3+Sqo617RibIzJbpwypAxgI1iHLuKzQvM4UQvoRXsIC3tie8sfBQQi981EbNlSF+7mBSQlEFlIAlbX03cTLLjJcIEACzWaFbu5d4BfmpOwJzuwrKQ8XvL+Ps9eSbUgK5nhuexJJ/xfumfZIQnsEzHShePhfYaIQ9Y3BKbw1cyLZ1pj3TpLR8VnIIRz1H1InYeQ4Q + + + + https://www.digst.dk/TSLDK_v6xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + DK + + + application/vnd.etsi.tsl+xml + + + + Digitaliseringsstyrelsen // CVR:34051178 + Danish Agency for Digitisation // CVR:34051178 + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/DK + + + + + + + + + MIIDrDCCApSgAwIBAgIJAJp9F/NFeDmmMA0GCSqGSIb3DQEBDQUAMG0xLjAsBgNVBAMMJUVzdG9uaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxCzAJBgNVBAYTAkVFMS4wLAYDVQQKDCVFc3RvbmlhbiBJbmZvcm1hdGlvbiBTeXN0ZW0gQXV0aG9yaXR5MB4XDTE5MDEyNTA5NDAwNloXDTI4MDcyNDA5NDAwNlowbTEuMCwGA1UEAwwlRXN0b25pYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjELMAkGA1UEBhMCRUUxLjAsBgNVBAoMJUVzdG9uaWFuIEluZm9ybWF0aW9uIFN5c3RlbSBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBMux4ivfdlZy9W75NgMWfD7ahajygYHCp8Tw9LxQ0vkmpuyaNNlXU+uj+yffWfekVgMoLaQrCpVIN0FF8ZMnnlsK600hpgnQNI+snPxU1u9BK6P87ZpoQU2wvan2oqjWflm06ybLzvvJrPJVNoVelrUDTY6SPngMbyqqpsdXo+dW8916ZoRUcEkTFWjQXVjhY1Lqsorbpaop1iv9BV2SXmsh4szRlqpu4dDSElWViBn0+A1ptiSAt7JINr0DDjfswqE+dhvjf6xq+IEaqUoMtGPKgz7SDqKKyg/KBO1ZGunUZE+91HKUASt+sPy3O3wMZM1SpZe1INEXQ0EQ4gytdAgMBAAGjTzBNMAwGA1UdEwQFMAMCAQAwCwYDVR0PBAQDAgeAMB0GA1UdDgQWBBScAndEhykw8vEHVFuQ7XPtHnqFajARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQENBQADggEBAHaLcIDZmUA9Bcv7TjuQW2Q3cFWFSmKc8aT5HaRKBxRRy10j9czqT439w/smT4De8JYyULXU+SoUX6/5sjmcpYxczFIC6imH8XLTgOca3vRAhek5iM80+h6v8CvxQHrsqNiSrLImE4LWfXWhQ/WPcyQdNrHCFrynJ9Gf6Q1DzQBRstpj5I8WjE+ME+w+vDj+VHHjI4wd5NkJhwwaF5PFB6uRrdb95e1dqLe4CTALe6+dh2QYhzSWZ+AZ2GaF+LlFreHhyV0sl+KwcNKSzSotStHL0zPTnq/yxPNaihhFmAlPdZdwq7vTN+yn5PAqEcfhTn06Gf5yDZjrmf5JO5eMpzM= + + + + + MIIDrDCCApSgAwIBAgIJANYjcEBni/iUMA0GCSqGSIb3DQEBDQUAMG0xLjAsBgNVBAMMJUVzdG9uaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxCzAJBgNVBAYTAkVFMS4wLAYDVQQKDCVFc3RvbmlhbiBJbmZvcm1hdGlvbiBTeXN0ZW0gQXV0aG9yaXR5MB4XDTE5MDEyNTA5NDI1N1oXDTI5MDEyNDA5NDI1N1owbTEuMCwGA1UEAwwlRXN0b25pYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjELMAkGA1UEBhMCRUUxLjAsBgNVBAoMJUVzdG9uaWFuIEluZm9ybWF0aW9uIFN5c3RlbSBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/Cin6xlZ6to4wWlT0KC5eBk3WVexaN1FOHLW42uXScIDITD+2P6w5XWCZCElhW7PBHQZZ6+gSSVSghafOqOPXvstSOv8UX7wM1ds+CxCTBQu3gNsu1DqEl/z7vVXTumXwtvtfM/fZkB5+7yQ4DXPmkvdWp4g0BOf8rZcOeQYSPipbgSQho/QZmfztueuWbneJ0jyLQ7vSh1YdFlFNNBzC4piycOh5d7Al7Q5+jdr0MaT8ZVevS16vWQFlmCwjpDXQeleTi4jiGUTNZPIjDPT2VHlAHVwK8/VLNo0XQfF1/Ja5eIX9mOocGgzo6ZNSyOVyiMiMav6E7IleDNzw4wtDAgMBAAGjTzBNMAwGA1UdEwQFMAMCAQAwCwYDVR0PBAQDAgeAMB0GA1UdDgQWBBR/uDLzHBU2e7Qnni1CMObW/Tm9+jARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQENBQADggEBADrNqccyitbRwqTFqPhW03VOkITeJ57IX6bM89f4XXkgzW2VpjIXSS7ThyIjtXzcq5MIJgll4nBhH54wkdXNIwRL5lPAFUEc/lvSZSt2F/9DeYA4t0dCkzj0L79FEsUv9qZJpuXLEh4JoiLtpYZ9/s7MujsmzfoR24DFM4A4Ny9l5mgfBRMymjWCzT2cc+OTL1uNTv2YGXK7NwVPQfMwo9bs70xGVguwcTnjy3qydajt263kjntul5E+VSqz5upd6raF2Ty9sNnUiQLDFT641WhnBltnfQecK1LnejyvfZMJmsDNHJh9T7eWg5Hpd5DwkcHHU+fdNdh6bewqQEiqHbs= + + + + https://sr.riik.ee/tsl/estonian-tsl.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + EE + + + application/pdf + + + + Estonian Information System Authority + Riigi Infosüsteemi Amet + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EE + + + + + + + + + MIIDrDCCApSgAwIBAgIJAJp9F/NFeDmmMA0GCSqGSIb3DQEBDQUAMG0xLjAsBgNVBAMMJUVzdG9uaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxCzAJBgNVBAYTAkVFMS4wLAYDVQQKDCVFc3RvbmlhbiBJbmZvcm1hdGlvbiBTeXN0ZW0gQXV0aG9yaXR5MB4XDTE5MDEyNTA5NDAwNloXDTI4MDcyNDA5NDAwNlowbTEuMCwGA1UEAwwlRXN0b25pYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjELMAkGA1UEBhMCRUUxLjAsBgNVBAoMJUVzdG9uaWFuIEluZm9ybWF0aW9uIFN5c3RlbSBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBMux4ivfdlZy9W75NgMWfD7ahajygYHCp8Tw9LxQ0vkmpuyaNNlXU+uj+yffWfekVgMoLaQrCpVIN0FF8ZMnnlsK600hpgnQNI+snPxU1u9BK6P87ZpoQU2wvan2oqjWflm06ybLzvvJrPJVNoVelrUDTY6SPngMbyqqpsdXo+dW8916ZoRUcEkTFWjQXVjhY1Lqsorbpaop1iv9BV2SXmsh4szRlqpu4dDSElWViBn0+A1ptiSAt7JINr0DDjfswqE+dhvjf6xq+IEaqUoMtGPKgz7SDqKKyg/KBO1ZGunUZE+91HKUASt+sPy3O3wMZM1SpZe1INEXQ0EQ4gytdAgMBAAGjTzBNMAwGA1UdEwQFMAMCAQAwCwYDVR0PBAQDAgeAMB0GA1UdDgQWBBScAndEhykw8vEHVFuQ7XPtHnqFajARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQENBQADggEBAHaLcIDZmUA9Bcv7TjuQW2Q3cFWFSmKc8aT5HaRKBxRRy10j9czqT439w/smT4De8JYyULXU+SoUX6/5sjmcpYxczFIC6imH8XLTgOca3vRAhek5iM80+h6v8CvxQHrsqNiSrLImE4LWfXWhQ/WPcyQdNrHCFrynJ9Gf6Q1DzQBRstpj5I8WjE+ME+w+vDj+VHHjI4wd5NkJhwwaF5PFB6uRrdb95e1dqLe4CTALe6+dh2QYhzSWZ+AZ2GaF+LlFreHhyV0sl+KwcNKSzSotStHL0zPTnq/yxPNaihhFmAlPdZdwq7vTN+yn5PAqEcfhTn06Gf5yDZjrmf5JO5eMpzM= + + + + + MIIDrDCCApSgAwIBAgIJANYjcEBni/iUMA0GCSqGSIb3DQEBDQUAMG0xLjAsBgNVBAMMJUVzdG9uaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IxCzAJBgNVBAYTAkVFMS4wLAYDVQQKDCVFc3RvbmlhbiBJbmZvcm1hdGlvbiBTeXN0ZW0gQXV0aG9yaXR5MB4XDTE5MDEyNTA5NDI1N1oXDTI5MDEyNDA5NDI1N1owbTEuMCwGA1UEAwwlRXN0b25pYW4gVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvcjELMAkGA1UEBhMCRUUxLjAsBgNVBAoMJUVzdG9uaWFuIEluZm9ybWF0aW9uIFN5c3RlbSBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/Cin6xlZ6to4wWlT0KC5eBk3WVexaN1FOHLW42uXScIDITD+2P6w5XWCZCElhW7PBHQZZ6+gSSVSghafOqOPXvstSOv8UX7wM1ds+CxCTBQu3gNsu1DqEl/z7vVXTumXwtvtfM/fZkB5+7yQ4DXPmkvdWp4g0BOf8rZcOeQYSPipbgSQho/QZmfztueuWbneJ0jyLQ7vSh1YdFlFNNBzC4piycOh5d7Al7Q5+jdr0MaT8ZVevS16vWQFlmCwjpDXQeleTi4jiGUTNZPIjDPT2VHlAHVwK8/VLNo0XQfF1/Ja5eIX9mOocGgzo6ZNSyOVyiMiMav6E7IleDNzw4wtDAgMBAAGjTzBNMAwGA1UdEwQFMAMCAQAwCwYDVR0PBAQDAgeAMB0GA1UdDgQWBBR/uDLzHBU2e7Qnni1CMObW/Tm9+jARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQENBQADggEBADrNqccyitbRwqTFqPhW03VOkITeJ57IX6bM89f4XXkgzW2VpjIXSS7ThyIjtXzcq5MIJgll4nBhH54wkdXNIwRL5lPAFUEc/lvSZSt2F/9DeYA4t0dCkzj0L79FEsUv9qZJpuXLEh4JoiLtpYZ9/s7MujsmzfoR24DFM4A4Ny9l5mgfBRMymjWCzT2cc+OTL1uNTv2YGXK7NwVPQfMwo9bs70xGVguwcTnjy3qydajt263kjntul5E+VSqz5upd6raF2Ty9sNnUiQLDFT641WhnBltnfQecK1LnejyvfZMJmsDNHJh9T7eWg5Hpd5DwkcHHU+fdNdh6bewqQEiqHbs= + + + + https://sr.riik.ee/tsl/estonian-tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + EE + + + application/vnd.etsi.tsl+xml + + + + Estonian Information System Authority + Riigi Infosüsteemi Amet + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EE + + + + + + + + + MIICZjCCAgugAwIBAgIJANeHQWATgt+cMAoGCCqGSM49BAMEMIGQMQswCQYDVQQGEwJFTDEPMA0GA1UEBwwGQXRoZW5zMT4wPAYDVQQKDDVIZWxsZW5pYyBUZWxlY29tbXVuaWNhdGlvbnMgYW5kIFBvc3QgQ29tbWlzc2lvbiwgRUVUVDEwMC4GA1UEAwwnSGVsbGVuaWMgVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvci0xMB4XDTIxMDMwNTA3MzUwOVoXDTI2MDkwMzA3MzUwOVowgZAxCzAJBgNVBAYTAkVMMQ8wDQYDVQQHDAZBdGhlbnMxPjA8BgNVBAoMNUhlbGxlbmljIFRlbGVjb21tdW5pY2F0aW9ucyBhbmQgUG9zdCBDb21taXNzaW9uLCBFRVRUMTAwLgYDVQQDDCdIZWxsZW5pYyBUcnVzdGVkIExpc3QgU2NoZW1lIE9wZXJhdG9yLTEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAR7MlwDiLTryq1z4tJ/6V3ZBeBjA3YVrpuA25ddLyfBaNXKdNGxJaavWtH+u3exNSxIsxJYj++3D/UyQBsiToG3o0wwSjAdBgNVHQ4EFgQUpRIBCdaHCtohtG3o2p2BsPIcZFwwCQYDVR0TBAIwADALBgNVHQ8EBAMCBsAwEQYDVR0lBAowCAYGBACRNwMAMAoGCCqGSM49BAMEA0kAMEYCIQCiQVBWUFSUMDyPd2EY1PmCAmfkOBgswnzqOsSe4WutigIhAM7d4W05/9tdgOjbbgLwkd6WKTqVYpFMrTG6l/ahLAlV + + + + + MIICZTCCAgugAwIBAgIJAJd82J1RAQwRMAoGCCqGSM49BAMEMIGQMQswCQYDVQQGEwJFTDEPMA0GA1UEBwwGQXRoZW5zMT4wPAYDVQQKDDVIZWxsZW5pYyBUZWxlY29tbXVuaWNhdGlvbnMgYW5kIFBvc3QgQ29tbWlzc2lvbiwgRUVUVDEwMC4GA1UEAwwnSGVsbGVuaWMgVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvci0yMB4XDTIxMDMwNTA3MzgzM1oXDTI2MTIwNDA3MzgzM1owgZAxCzAJBgNVBAYTAkVMMQ8wDQYDVQQHDAZBdGhlbnMxPjA8BgNVBAoMNUhlbGxlbmljIFRlbGVjb21tdW5pY2F0aW9ucyBhbmQgUG9zdCBDb21taXNzaW9uLCBFRVRUMTAwLgYDVQQDDCdIZWxsZW5pYyBUcnVzdGVkIExpc3QgU2NoZW1lIE9wZXJhdG9yLTIwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAReEiebLPcZnmU/nll2kxrFFpW97bb8DyOyWyn6xYlztH+vFtGg0wKu2X5XXg/42Dl6E72JDtqgWALlrYyq/gYYo0wwSjAdBgNVHQ4EFgQUN/GgUJ5e1FePhr2duzrjTu9qqF4wCQYDVR0TBAIwADALBgNVHQ8EBAMCBsAwEQYDVR0lBAowCAYGBACRNwMAMAoGCCqGSM49BAMEA0gAMEUCIF4ekbBcA7Ax/ynJNryVEEji0HN9jhvi79gMhDJki2PPAiEArfSJ+DyZOyH6H/Y5bIzTCwvP2UphrzW7+4AyCvL7chg= + + + + + MIICZTCCAgugAwIBAgIJAN5sdH/XZ8AmMAoGCCqGSM49BAMEMIGQMQswCQYDVQQGEwJFTDEPMA0GA1UEBwwGQXRoZW5zMT4wPAYDVQQKDDVIZWxsZW5pYyBUZWxlY29tbXVuaWNhdGlvbnMgYW5kIFBvc3QgQ29tbWlzc2lvbiwgRUVUVDEwMC4GA1UEAwwnSGVsbGVuaWMgVHJ1c3RlZCBMaXN0IFNjaGVtZSBPcGVyYXRvci0zMB4XDTIxMDMwNTA3NDAxNVoXDTI3MDMwNDA3NDAxNVowgZAxCzAJBgNVBAYTAkVMMQ8wDQYDVQQHDAZBdGhlbnMxPjA8BgNVBAoMNUhlbGxlbmljIFRlbGVjb21tdW5pY2F0aW9ucyBhbmQgUG9zdCBDb21taXNzaW9uLCBFRVRUMTAwLgYDVQQDDCdIZWxsZW5pYyBUcnVzdGVkIExpc3QgU2NoZW1lIE9wZXJhdG9yLTMwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAATen1l7TKrMXbf0L60f23u2zWyT1k6r7+xpMCqzsF0zS8c2Ylpb6DM8dxsjGGhg+X4K7bVBocLAwzybrekQ4uVmo0wwSjAdBgNVHQ4EFgQUKJj5CuO6uvve0QvsmdN7pKka5jUwCQYDVR0TBAIwADALBgNVHQ8EBAMCBsAwEQYDVR0lBAowCAYGBACRNwMAMAoGCCqGSM49BAMEA0gAMEUCIQDaLJAf7eSTlnefSfeDDArkLiS/iWbNpIYe5696KnLAcQIgRElGtyj8pa0+FWk0KJR/Wu7D1DhgPltex75WCdGoKvQ= + + + + + MIICZTCCAgqgAwIBAgIUK1cRfQbnZfFFvXhfG94jF72d3vgwCgYIKoZIzj0EAwQwgYoxCzAJBgNVBAYTAkVMMQ8wDQYDVQQHDAZBdGhlbnMxODA2BgNVBAoML0hlbGxlbmljIFRlbGVjb21tdW5pY2F0aW9ucyBhbmQgUG9zdCBDb21taXNzaW9uMTAwLgYDVQQDDCdIZWxsZW5pYyBUcnVzdGVkIExpc3QgU2NoZW1lIE9wZXJhdG9yLTEwHhcNMjYwNzMxMTYzODM4WhcNMzEwODAyMTYzODM4WjCBijELMAkGA1UEBhMCRUwxDzANBgNVBAcMBkF0aGVuczE4MDYGA1UECgwvSGVsbGVuaWMgVGVsZWNvbW11bmljYXRpb25zIGFuZCBQb3N0IENvbW1pc3Npb24xMDAuBgNVBAMMJ0hlbGxlbmljIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3ItMTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABAl/WNixjx1KT3LeOb9FAnPeBMbCNabgghPRWXX36MAZAX0JNV/z0p8BPqUdIeAMepxoz92B6f+DpD6qvLK2BkejTDBKMB0GA1UdDgQWBBRW902VSBdq/WeNFEepYFQx5rir7TAJBgNVHRMEAjAAMAsGA1UdDwQEAwIGwDARBgNVHSUECjAIBgYEAJE3AwAwCgYIKoZIzj0EAwQDSQAwRgIhAIEv4vhDYdZ81JzlgblZVq4wzneXY73HohF/V+9kOrnkAiEA7lJ93TipuCATwQOycI78oWH9XPxdNuhtDQSAiZAC/+o= + + + + + MIICYzCCAgqgAwIBAgIURmFC9OMrL2/bSkH5zGr+uLpRyx8wCgYIKoZIzj0EAwQwgYoxCzAJBgNVBAYTAkVMMQ8wDQYDVQQHDAZBdGhlbnMxODA2BgNVBAoML0hlbGxlbmljIFRlbGVjb21tdW5pY2F0aW9ucyBhbmQgUG9zdCBDb21taXNzaW9uMTAwLgYDVQQDDCdIZWxsZW5pYyBUcnVzdGVkIExpc3QgU2NoZW1lIE9wZXJhdG9yLTQwHhcNMjYwNzMxMTY0MzA0WhcNMzIwMTAxMTY0MzA0WjCBijELMAkGA1UEBhMCRUwxDzANBgNVBAcMBkF0aGVuczE4MDYGA1UECgwvSGVsbGVuaWMgVGVsZWNvbW11bmljYXRpb25zIGFuZCBQb3N0IENvbW1pc3Npb24xMDAuBgNVBAMMJ0hlbGxlbmljIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3ItNDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABO4KiOeF/6ymN8f4iPfBXSCCrhmpXRk36oW9vgzyTFvTxLZSFodlCEwLkU+A0jRoirY99d3ORmEtmjL+7HSC8cujTDBKMB0GA1UdDgQWBBRtdnoOgYEo9ZTZVvLOuvdMKyuJMTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIGwDARBgNVHSUECjAIBgYEAJE3AwAwCgYIKoZIzj0EAwQDRwAwRAIgLvYtoBV2P1VwEV5g87QNcB0TwR26SiscQpUhC/aPgjUCIG+FsXjS0lRiwlOlCjC859PdOFKFF3pTElSpISSkOLwc + + + + + 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 + + + + https://www.eett.gr/tsl/tl-el.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + EL + + + application/vnd.etsi.tsl+xml + + + + Hellenic Telecommunications and Post Commission, EETT + Εθνική Επιτροπή Τηλεπικοινωνιών και Ταχυδρομείων - EETT + Εθνική Επιτροπή Τηλεπικοινωνιών και Ταχυδρομείων + Hellenic Telecommunications and Post Commission + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EL + + + + + + + + + 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 + + + + + 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 + + + + https://tsl.digital.gob.es/TSL.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + ES + + + application/pdf + + + + MINISTRY OF ECONOMIC AFFAIRS AND DIGITAL TRANSFORMATION + MINISTERIO DE ASUNTOS ECONOMICOS Y TRANSFORMACION DIGITAL + MINISTRY OF DIGITAL TRANSFORMATION + MINISTERIO DE TRANSFORMACION DIGITAL + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/ES + + + + + + + + + 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 + + + + + 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 + + + + https://tsl.digital.gob.es/TSL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + ES + + + application/vnd.etsi.tsl+xml + + + + MINISTRY OF ECONOMIC AFFAIRS AND DIGITAL TRANSFORMATION + MINISTERIO DE ASUNTOS ECONOMICOS Y TRANSFORMACION DIGITAL + MINISTRY OF DIGITAL TRANSFORMATION + MINISTERIO DE TRANSFORMACION DIGITAL + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/ES + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + MIIFhTCCA22gAwIBAgIFFKu+n4swDQYJKoZIhvcNAQENBQAwUjELMAkGA1UEBhMCRkkxJzAlBgNVBAoMHkxpaWtlbm5lLSBqYSB2aWVzdGludMOkdmlyYXN0bzEaMBgGA1UEAwwRU2NoZW1lT3BlcmF0b3IgSUkwHhcNMjUwNDE2MDAwMDAwWhcNMjgxMjE2MDAwMDAwWjBSMQswCQYDVQQGEwJGSTEnMCUGA1UECgweTGlpa2VubmUtIGphIHZpZXN0aW50w6R2aXJhc3RvMRowGAYDVQQDDBFTY2hlbWVPcGVyYXRvciBJSTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL11KF1pneMF86KKSWA3KYBflo/pMweA/AqUxx6fStMyegS07zyXtVnKmx9oFtiK0PtL7yJde8z26uYBk+R2udSC5NUWNv3qYRpBPXiYPfU+iYj+UomEt6MWEriw4ikaLlSgg7rO5RXg38fjdVg9R+Vv2t8m2//VSDbvqyC3eXWt+kyx9LHF1lSL9R3B2PDdMtO/LPufKyvdw9qKym+7/jzGfma/JWwO23Rhvu2+C3z+XPwt1CKpSrYy6VZofhfoCSvueI+pTXJXwi1J6bPzMkuNUsRC+s+HNvEk23GdxomrSnm//9y4exW4HjxiSoZGtSpBivo/stWeX1g425gjfLNAcq/WfUyMp2Vx40Zh2yvO/HgNuqCj6aWh2rsHAj2Gl3seO5TcCcnwYpnwB3BHArv5UjMbbK05pimERhBQjjnRxbowFy8IeAY0P9Sv6P/YUGMzdtTuynU/V1DxTkOl7266urpG6nJKplrM5SvHL31T6nNjPK8xxi2zHZNFlwOGUIQmeyPHooW3nZZPfdI5GSntUtVkjxyEWMS8NeUPCSgAD1jaOqnaTffgB6u1L6OCuoOn44tiGLVVdcwyNzlISttDHhxqAmSZqncdFLq+z2O2XkDV3JGvxsoRZJvGzEJsoBNNtJ7e4yfHqaGX/f9T8yxok+sxa3SJqBCToJ/Xf0B5AgMBAAGjYjBgMB0GA1UdDgQWBBTisFhrVOekTsPbefbUyZvtacDTgTAJBgNVHRMEAjAAMA4GA1UdDwEB/wQEAwIGwDARBgNVHSAECjAIMAYGBFUdIAAwEQYDVR0lBAowCAYGBACRNwMAMA0GCSqGSIb3DQEBDQUAA4ICAQATZuB0BpxCq4RVJq00ombHwBuJXCeI7vVtcIbotX2q7fb6ZM8Y1GasvXrB5C/nIwQ4hjta4k/pV4sL0VmZNcYUZq7ycDW7Pc9ZW6jVYpPSYONbmi43YDZ5QfmHUnr0aQqb6fm7I97OThcFgeCLUAf98TQ6uxs9x2SrkE1wYjqtSLE/IZ+W6vceNMsZv9a7BMr7MXOBTum9u6SPrSvF0zxhOgKQ8AoVY+uQgnXB5Tlh7T8UmqzeiBHUKbQrY1+KyCq3eqYiRUbEKixnoitGxtnRjSUj+NJIh+z9DhQTtLY5Xqa4rCpbNrEzoRHENInkHYSg3VnDj0vkjcvqIZT+rtL21M0pvDOulJnO8AhsjB8p7KM74d+KuMy3KX2iQlV2hvZGxDg/nng2pto12uDnWunmAfPRTzn59KHZbhSPKT/ZwMDw/3RDH/8N+G6PbIjArDBuO88EgF9ExxkDHdLWossOhm/xCanEmaVVdFNUj5gwGDYhOa1SDzZ9PxW2tp1heMmY++N0zNJ9PRj+ASsJArCwQ8uRBdKOV2yyDvdLvZkA3KWa/aRD5UHF5eksd/Uz2YSM+2S0luyMDjNkEk9VGy5+K6YrdZXuhPft+ph0/MouYhQYnF6r/QpJuYe8zrdxwKIoLRh6uMrq+IEVNFNxkpPglwj2zgUuIZxX6N6qJarphA== + + + + + MIIFqzCCA5OgAwIBAgIFFO7m0G0wDQYJKoZIhvcNAQENBQAwZTELMAkGA1UEBhMCRkkxJzAlBgNVBAoMHkxpaWtlbm5lLSBqYSB2aWVzdGludMOkdmlyYXN0bzEZMBcGA1UEAwwQU2NoZW1lT3BlcmF0b3IgSTESMBAGA1UEBRMJOTEyOTAxNjQwMB4XDTI1MDQxNjAwMDAwMFoXDTI4MDUxNjAwMDAwMFowZTELMAkGA1UEBhMCRkkxJzAlBgNVBAoMHkxpaWtlbm5lLSBqYSB2aWVzdGludMOkdmlyYXN0bzEZMBcGA1UEAwwQU2NoZW1lT3BlcmF0b3IgSTESMBAGA1UEBRMJOTEyOTAxNjQwMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAsp3jC2dwdCkgY9sCtBgyOE/Qw9rguWbvODGTLHTmjXgeSm2DzsZ6oLr1Z7p0CXD1dIIwY5O6SLVre4Vo+/valxux+iLqb0o1gA/j6S23grFWGZHm5nSv1Lyz6jAqBekOo24xQWuvjR74bDcq+yFe8tcrvj9hLTajWVGzMhL6srOOVb7gf2Q8rrBNXHCZflbN+Ca20qZdsr49WwJ0nrNG6EdxOGR0nBjQU0DuCETGjmh+Hev4BA4sncmw4xMF16/XceVN+D1whTDXjo2ktvtFgrWKuc9hq57mwDcORrg8lkoCPkt2kdyHvcttWDZTPGk1m1rUrdCIlUQ+GvGbe6FJDqu8SopYmI7PFU+rr06oZlor+RSbpbR+p/pX56O7xdoWFUOtwh3Y054b7UyfJeVfVKxEJTkKJXoPk5xWeZa/ItkikC5FGtDXFcNks15xDk3oN86J45Tt+ga435zbeqghrZ/luzODzIOnSxtqblaCMHKt8euriL8/7dksxoIhlS0B/OPw4Pw194ludzY9wrhpawONqoEV8UPbfr4i+nh80vbsFs4O56B41ADWRLz3YxRfk3VJo4mcjAQJdFa/6aEXNGEiDc3A4f8Qmuf+jqAyIXufdfSPD4cyo2RW3KLovK7Y/1dz+pQHbxCFbJQgMRb0jiakAmCphNr7bPkdlITSqrUCAwEAAaNiMGAwHQYDVR0OBBYEFLtXuCf8hiUW0VJjpLmoDJFDuqJ3MAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQENBQADggIBADm+AAkPuBbncUbxP8IrSjggZdPTojRduiuhObafFCteVn2qq3285UR4Ilq5gguQLqenu7KxWPjEfNecXBACP5HuFQpw2+P0rsd9X0Rq2ZsDEDjgn84xotylGC5wSsCOhDGF0/LeEvsC4QScpHLlCdwPJZoqEudJjU2Px0jeb7FLieltB/DhrjoLbUNqz6QYjdSIxuOk0KojYhNOpMwQ422HWQrtz6uu2gBVhMRsC38ZFt28Y+7yyhIkBwV8GOY5vmbb9JN5mtpXXBEe+nl6r9jGUZNZo4OlXlQVvAFQu1xBYbYzepScP70RnQUwFxsdCh54QXUS8I5yjUuYpgDpcwDtNph+hCvC1YE7GP4Ik8hyY5rTXIF6kScnyLlQAbkEiCkZykG7t8pGUEd96hIU6wZymjxCbSeNF4+UzlFP/4aTaX7uJZP+s9G1CtylnDdtvHPVVZKH5KWA+C0Do1MeARyreBBVPIQCXOGfZndthEcaU9C07PJfBvYiCUjY+43ssabG1W4NA8DFeObyF0f6QKWel0S+8YDSE2V6DxMVJkClbJ0in1JRJ28qh8KUv2kHsCfxNlPnM7HXNbxAHBREU02Ca5ZzPJ9yNN0SSRVjSpbJNDL7UoXpNc5AEY//JvmGUjDJAnN+4ibL7uGEVE4vr2THtS1w5z4C/UhVfVXweLO3 + + + + https://dp.trustedlist.fi/fi-tl-v6.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + FI + + + application/vnd.etsi.tsl+xml + + + + Finnish Transport and Communications Agency + Transport- och kommunikationsverket + Liikenne- ja viestintävirasto + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/FI + + + + + + + + + MIIFXDCCBESgAwIBAgIUbR6J39k5qND1JSlgxEd+bJgAQx4wDQYJKoZIhvcNAQELBQAwgZcxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTEwLwYDVQQDDChBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBQZXJzb25uZXMgQUFFMQowCAYDVQQFEwE0MB4XDTI0MTAwODE1NTA0OFoXDTI3MTAwODE1NTA0OFowfDELMAkGA1UEBhMCRlIxDTALBgNVBAoMBEFOVFMxFzAVBgNVBAsMDjAwMDIgMTMwMDA3NjY5MSMwIQYDVQQDDBpNYXRoaWV1IEpPUlJZIDMzMTAwMDM4OThqbTEQMA4GA1UEKgwHTWF0aGlldTEOMAwGA1UEBAwFSk9SUlkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCTu9SgITZn9p36gIgDSndt/g7qpLJzj2Bt9t28BkprA6U8I7ukbgqcEeQwJKVhcx4OZ4FHMP43jZlCplU1bCYNL5+an98mlrDdSSFbV8ano4tWuDqD2d14jxwWpYxto6ZHtPC+23vzDP/xDUwdnnl6BIr5FemEmi946s8puLjDLtEMUTpWaAo+WH7/T8g1hxlco3x45v47z7nR/MkuukOcvYL09jcER1s+NWxVEb2whiiztgVbD1Od2aZh9H9uj1T7BfxDSlapHCQPmJfvfR6TSWy6GfJFe6FF/bud8o33etgCeNhq3DFG5oRbOtfOF5ekFJtuovf9lOv6RK4foNbFAgMBAAGjggG4MIIBtDAdBgNVHQ4EFgQUpLKvYlHeCngPPnQffCmCPOJRQx0wHwYDVR0jBBgwFoAUHGyk9w7WVN5Fz1CBst1ZiLMob94wCQYDVR0TBAIwADAOBgNVHQ8BAf8EBAMCBkAwNwYIKwYBBQUHAQMEKzApMAgGBgQAjkYBATAIBgYEAI5GAQQwEwYGBACORgEGMAkGBwQAjkYBBgEwRwYDVR0fBEAwPjA8oDqgOIY2aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYW50c2F2My9hY19wZXJzb25uZXNfYWFlXzQuY3JsMCQGA1UdEQQdMBuBGW1hdGhpZXUuam9ycnlAc3NpLmdvdXYuZnIwGAYDVR0gBBEwDzANBgsqgXoBgUgDAQIDAjCBlAYIKwYBBQUHAQEEgYcwgYQwPwYIKwYBBQUHMAGGM2h0dHA6Ly9vY3NwLmFudHMuZ291di5mci9hbnRzYXYzL2FjX3BlcnNvbm5lc19hYWVfNDBBBggrBgEFBQcwAoY1aHR0cDovL3NwLmFudHMuZ291di5mci9hbnRzYXYzL2FjX3BlcnNvbm5lc19hYWVfNC5jZXIwDQYJKoZIhvcNAQELBQADggEBAKU9mevhWyrKGEUqXCiqROvQjwl9adUAcH0F8gqQnTc8notCarIg18cAMx82uIdzswKDEkz5ZHQbx562B1+CD2aIgm5ozvmzA+t1MdJuwUQDJghFLI85VwA0eIcrcmJDwxlArNWMAPnNBIwESEC82kCNMHza6Z821qp0Ei5YhfxomBMyNbDB1/riOnr8YOmMzlqUGfxUwB6V4P6bAQAJAKMhtmI7HioVeNp3dCHhc/f1R3sihdCDkwufsG2KMo3btyh++xGwx6jfbEaLxXNhBuCMw/YE+oGXGP3KRczIGyjvWNIwJ8ZtZXCrioVWB0VhfE6ZxNhQRonyS8KLIe7XVOQ= + + + + + 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 + + + + https://messervices.cyber.gouv.fr/visas/tl-fr_v6.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + FR + + + application/pdf + + + + French network and information security agency + Agence nationale de la sécurité des systèmes d'information (ANSSI) + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/FR + + + + + + + + + MIIFXDCCBESgAwIBAgIUbR6J39k5qND1JSlgxEd+bJgAQx4wDQYJKoZIhvcNAQELBQAwgZcxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTEwLwYDVQQDDChBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBQZXJzb25uZXMgQUFFMQowCAYDVQQFEwE0MB4XDTI0MTAwODE1NTA0OFoXDTI3MTAwODE1NTA0OFowfDELMAkGA1UEBhMCRlIxDTALBgNVBAoMBEFOVFMxFzAVBgNVBAsMDjAwMDIgMTMwMDA3NjY5MSMwIQYDVQQDDBpNYXRoaWV1IEpPUlJZIDMzMTAwMDM4OThqbTEQMA4GA1UEKgwHTWF0aGlldTEOMAwGA1UEBAwFSk9SUlkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCTu9SgITZn9p36gIgDSndt/g7qpLJzj2Bt9t28BkprA6U8I7ukbgqcEeQwJKVhcx4OZ4FHMP43jZlCplU1bCYNL5+an98mlrDdSSFbV8ano4tWuDqD2d14jxwWpYxto6ZHtPC+23vzDP/xDUwdnnl6BIr5FemEmi946s8puLjDLtEMUTpWaAo+WH7/T8g1hxlco3x45v47z7nR/MkuukOcvYL09jcER1s+NWxVEb2whiiztgVbD1Od2aZh9H9uj1T7BfxDSlapHCQPmJfvfR6TSWy6GfJFe6FF/bud8o33etgCeNhq3DFG5oRbOtfOF5ekFJtuovf9lOv6RK4foNbFAgMBAAGjggG4MIIBtDAdBgNVHQ4EFgQUpLKvYlHeCngPPnQffCmCPOJRQx0wHwYDVR0jBBgwFoAUHGyk9w7WVN5Fz1CBst1ZiLMob94wCQYDVR0TBAIwADAOBgNVHQ8BAf8EBAMCBkAwNwYIKwYBBQUHAQMEKzApMAgGBgQAjkYBATAIBgYEAI5GAQQwEwYGBACORgEGMAkGBwQAjkYBBgEwRwYDVR0fBEAwPjA8oDqgOIY2aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYW50c2F2My9hY19wZXJzb25uZXNfYWFlXzQuY3JsMCQGA1UdEQQdMBuBGW1hdGhpZXUuam9ycnlAc3NpLmdvdXYuZnIwGAYDVR0gBBEwDzANBgsqgXoBgUgDAQIDAjCBlAYIKwYBBQUHAQEEgYcwgYQwPwYIKwYBBQUHMAGGM2h0dHA6Ly9vY3NwLmFudHMuZ291di5mci9hbnRzYXYzL2FjX3BlcnNvbm5lc19hYWVfNDBBBggrBgEFBQcwAoY1aHR0cDovL3NwLmFudHMuZ291di5mci9hbnRzYXYzL2FjX3BlcnNvbm5lc19hYWVfNC5jZXIwDQYJKoZIhvcNAQELBQADggEBAKU9mevhWyrKGEUqXCiqROvQjwl9adUAcH0F8gqQnTc8notCarIg18cAMx82uIdzswKDEkz5ZHQbx562B1+CD2aIgm5ozvmzA+t1MdJuwUQDJghFLI85VwA0eIcrcmJDwxlArNWMAPnNBIwESEC82kCNMHza6Z821qp0Ei5YhfxomBMyNbDB1/riOnr8YOmMzlqUGfxUwB6V4P6bAQAJAKMhtmI7HioVeNp3dCHhc/f1R3sihdCDkwufsG2KMo3btyh++xGwx6jfbEaLxXNhBuCMw/YE+oGXGP3KRczIGyjvWNIwJ8ZtZXCrioVWB0VhfE6ZxNhQRonyS8KLIe7XVOQ= + + + + + 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 + + + + https://messervices.cyber.gouv.fr/visas/tl-fr_v6.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + FR + + + application/vnd.etsi.tsl+xml + + + + French network and information security agency + Agence nationale de la sécurité des systèmes d'information (ANSSI) + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/FR + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://gov.hr/UserDocsImages/Usluge%20povjerenja/Pouzdani_popis_RH.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + HR + + + application/vnd.etsi.tsl+xml + + + + Ministry of Justice Public Administration and Digital Transformation + MINISTARSTVO PRAVOSUĐA UPRAVE I DIGITALNE TRANSFORMACIJE + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/HR + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + + + + MIIEPDCCAySgAwIBAgIEFgcFvTANBgkqhkiG9w0BAQsFADCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjQwODI3MTQxMDE1WhcNMjYwODI3MTQxMDE1WjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCCMKrgH9r7O1kpdyBGXzQfb20A/irIilysOeyEApVCuf1MCWm0smm7yM3XHTi+XAbnMn5n64GbhNgaMe4MB4vHtTUuObWXd2J4YblBx88WxPFfEVOmWWQ6n/C1TvMUGctG4zZ5YBPG2B13Qz02AEaN3WK4+/q5aJPYe91phT2xXX0HDDILBpgJngJPZLFzFNoRNWjuy/oKiaGRjXspFh/doUSXBb3R8/FgcWM0fFJS5a+Z3P280rvinnYO0fTp9HXP1be9QOHTe7BBqZv71xRFUyXA8Yptc3zCl1SDB+Ut0QJMg8g+/4AL2uwMM4zgtt3OAhxt31034cAieARaBKd1AgMBAAGjgZMwgZAwHwYDVR0jBBgwFoAULAbFjrK5NrypwBS9G2kaU8UDwEcwHQYDVR0OBBYEFCwGxY6yuTa8qcAUvRtpGlPFA8BHMA4GA1UdDwEB/wQEAwIGQDAdBgNVHREEFjAUgRJUTG9wZXJhdG9yQG5taGguaHUwDAYDVR0TAQH/BAIwADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAC1oqQciWI1zjVM9jDxGuxKKX8m3nJW/0ujzsWCGhHt2luCM2Y/KTzDHZER/U65gS3aAU13taUHiBwwryQgThKJuWrNZM5wNqRVG+eRT2BrhZEWwDG8T7ginErqSVil79UHTMrRjhV7StenvoM65L/LlU3K8/DC0j9aBzfkueq4Fd3wewqeg0L+NI7bz1Isle/14jcNlbZVbDJVzjdcnAH5ghYqmA3mra4yOKAAKsPLHE4DxzoEBqrSaHkdLSC4lCX+lF6RjYj3SeJ1OTQ/EZ6ej6NkHaC1Ga8iYwVCabNEQ5iETj6KPj6wbDfUFvE9dMystJWCAxjl7TKj7SRF5CZ8= + + + + + MIIEPDCCAySgAwIBAgIEGL7kKDANBgkqhkiG9w0BAQsFADCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjUwMzEzMTMwNDAwWhcNMjcwMzEzMTMwNDAwWjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCn+KSJvUjDp5+8qZGpLxfq9LxWFvMuvLwZiahurcGAm20G07vq80Ig8z4ogNaVZTkJsVpDHr/Liho+dyCVibpEJUo488vCU3xaKotdWmqAYwErOznFFZn4lkhwKnA5iLOQjAv8cauKaqMkTjJ2QlfVbLl1lO7TsH0rQc6RFVmbHgXIkPWoAmta9aa9PLMR5QkZV1R3UX8GMbeDQn4NalHpH5KRASIIX50R5RQkzT4lHiicy/SfG4kUhPCr45V4bi4v8lVWbmZB+qnZocOCVFVHCnzvSWOG9AzcOI7WxGTDHVSee/Q0lNFCMl+ph5X4dGELzDuU6vdHQ/8e3cM//la7AgMBAAGjgZMwgZAwHwYDVR0jBBgwFoAUVDSfANZ02mMQZPdbUTgv5nRce4UwHQYDVR0OBBYEFFQ0nwDWdNpjEGT3W1E4L+Z0XHuFMA4GA1UdDwEB/wQEAwIGQDAdBgNVHREEFjAUgRJUTG9wZXJhdG9yQG5taGguaHUwDAYDVR0TAQH/BAIwADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAIUlkUV+LUQz8P3xFjEKB+3glAfBdSUqbECk+0rYWGdomPwBTXlXW+C2+4cYCGpafFtOjPSKDGH2GNMmxcYTpb1bwCS81WTnhieApVMpA0AwK/QQAn0c2EEOYJKDQA3aejDwz/NFUqvYifxM3M9XgROYdHqvDobZTWMogpUxtLr1b6UweYpynnBts2mSKpiz7wwlOkhMq6nAP76lcdAH0TTmGBnMsbCcM4F53D2+j/o6LV0aOjKEruMXTeJgKMQabHJApjABP/qKGlw5Pf+njJaeCB7vR+zUXnQJFXHJ3NeKCR6wX97q4/px9BlCL45n4YlaCs8WP+wHOzAgGAkEbA4= + + + + + MIICvDCCAmKgAwIBAgIQMUdmkPWhKHAIh/0bZut+8TAKBggqhkjOPQQDAjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjYwMTI5MTAzNTEyWhcNMjkwMTI5MTAzNTEyWjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQ/o8JaS+2qJFFbP//TVYFPb8czVRXE0cOqH9u34xDjmWs4V48qv2Vg59ZnlqlFjnabf9UE7H7YeGDX377mFjxZo4GTMIGQMB8GA1UdIwQYMBaAFBgenYfi5s5xfubQF02EcxP+KFKBMB0GA1UdDgQWBBQYHp2H4ubOcX7m0BdNhHMT/ihSgTAOBgNVHQ8BAf8EBAMCBkAwHQYDVR0RBBYwFIESVExvcGVyYXRvckBubWhoLmh1MAwGA1UdEwEB/wQCMAAwEQYDVR0lBAowCAYGBACRNwMAMAoGCCqGSM49BAMCA0gAMEUCIEcEziRRANDet2XFq2edSZu5jmZYLOQ1vBL5jQMjeuJ4AiEAmeJioo79n2kikncxdXrLNT+qlvL+3TNPt5oNBwHSsxo= + + + + https://www.nmhh.hu/tl/pub/HU_TL.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + HU + + + application/pdf + + + + National Media and Infocommunications Authority, Hungary + Nemzeti Média- és Hírközlési Hatóság + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/HU + + + + + + + + + MIIEPDCCAySgAwIBAgIEFgcFvTANBgkqhkiG9w0BAQsFADCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjQwODI3MTQxMDE1WhcNMjYwODI3MTQxMDE1WjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCCMKrgH9r7O1kpdyBGXzQfb20A/irIilysOeyEApVCuf1MCWm0smm7yM3XHTi+XAbnMn5n64GbhNgaMe4MB4vHtTUuObWXd2J4YblBx88WxPFfEVOmWWQ6n/C1TvMUGctG4zZ5YBPG2B13Qz02AEaN3WK4+/q5aJPYe91phT2xXX0HDDILBpgJngJPZLFzFNoRNWjuy/oKiaGRjXspFh/doUSXBb3R8/FgcWM0fFJS5a+Z3P280rvinnYO0fTp9HXP1be9QOHTe7BBqZv71xRFUyXA8Yptc3zCl1SDB+Ut0QJMg8g+/4AL2uwMM4zgtt3OAhxt31034cAieARaBKd1AgMBAAGjgZMwgZAwHwYDVR0jBBgwFoAULAbFjrK5NrypwBS9G2kaU8UDwEcwHQYDVR0OBBYEFCwGxY6yuTa8qcAUvRtpGlPFA8BHMA4GA1UdDwEB/wQEAwIGQDAdBgNVHREEFjAUgRJUTG9wZXJhdG9yQG5taGguaHUwDAYDVR0TAQH/BAIwADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAC1oqQciWI1zjVM9jDxGuxKKX8m3nJW/0ujzsWCGhHt2luCM2Y/KTzDHZER/U65gS3aAU13taUHiBwwryQgThKJuWrNZM5wNqRVG+eRT2BrhZEWwDG8T7ginErqSVil79UHTMrRjhV7StenvoM65L/LlU3K8/DC0j9aBzfkueq4Fd3wewqeg0L+NI7bz1Isle/14jcNlbZVbDJVzjdcnAH5ghYqmA3mra4yOKAAKsPLHE4DxzoEBqrSaHkdLSC4lCX+lF6RjYj3SeJ1OTQ/EZ6ej6NkHaC1Ga8iYwVCabNEQ5iETj6KPj6wbDfUFvE9dMystJWCAxjl7TKj7SRF5CZ8= + + + + + MIIEPDCCAySgAwIBAgIEGL7kKDANBgkqhkiG9w0BAQsFADCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjUwMzEzMTMwNDAwWhcNMjcwMzEzMTMwNDAwWjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCn+KSJvUjDp5+8qZGpLxfq9LxWFvMuvLwZiahurcGAm20G07vq80Ig8z4ogNaVZTkJsVpDHr/Liho+dyCVibpEJUo488vCU3xaKotdWmqAYwErOznFFZn4lkhwKnA5iLOQjAv8cauKaqMkTjJ2QlfVbLl1lO7TsH0rQc6RFVmbHgXIkPWoAmta9aa9PLMR5QkZV1R3UX8GMbeDQn4NalHpH5KRASIIX50R5RQkzT4lHiicy/SfG4kUhPCr45V4bi4v8lVWbmZB+qnZocOCVFVHCnzvSWOG9AzcOI7WxGTDHVSee/Q0lNFCMl+ph5X4dGELzDuU6vdHQ/8e3cM//la7AgMBAAGjgZMwgZAwHwYDVR0jBBgwFoAUVDSfANZ02mMQZPdbUTgv5nRce4UwHQYDVR0OBBYEFFQ0nwDWdNpjEGT3W1E4L+Z0XHuFMA4GA1UdDwEB/wQEAwIGQDAdBgNVHREEFjAUgRJUTG9wZXJhdG9yQG5taGguaHUwDAYDVR0TAQH/BAIwADARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBAIUlkUV+LUQz8P3xFjEKB+3glAfBdSUqbECk+0rYWGdomPwBTXlXW+C2+4cYCGpafFtOjPSKDGH2GNMmxcYTpb1bwCS81WTnhieApVMpA0AwK/QQAn0c2EEOYJKDQA3aejDwz/NFUqvYifxM3M9XgROYdHqvDobZTWMogpUxtLr1b6UweYpynnBts2mSKpiz7wwlOkhMq6nAP76lcdAH0TTmGBnMsbCcM4F53D2+j/o6LV0aOjKEruMXTeJgKMQabHJApjABP/qKGlw5Pf+njJaeCB7vR+zUXnQJFXHJ3NeKCR6wX97q4/px9BlCL45n4YlaCs8WP+wHOzAgGAkEbA4= + + + + + MIICvDCCAmKgAwIBAgIQMUdmkPWhKHAIh/0bZut+8TAKBggqhkjOPQQDAjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwHhcNMjYwMTI5MTAzNTEyWhcNMjkwMTI5MTAzNTEyWjCBlDELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MUEwPwYDVQQKDDhOYXRpb25hbCBNZWRpYSBhbmQgSW5mb2NvbW11bmljYXRpb25zIEF1dGhvcml0eSwgSHVuZ2FyeTEvMC0GA1UEAwwmSHVuZ2FyaWFuIFRydXN0ZWQgTGlzdCBTY2hlbWUgT3BlcmF0b3IwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQ/o8JaS+2qJFFbP//TVYFPb8czVRXE0cOqH9u34xDjmWs4V48qv2Vg59ZnlqlFjnabf9UE7H7YeGDX377mFjxZo4GTMIGQMB8GA1UdIwQYMBaAFBgenYfi5s5xfubQF02EcxP+KFKBMB0GA1UdDgQWBBQYHp2H4ubOcX7m0BdNhHMT/ihSgTAOBgNVHQ8BAf8EBAMCBkAwHQYDVR0RBBYwFIESVExvcGVyYXRvckBubWhoLmh1MAwGA1UdEwEB/wQCMAAwEQYDVR0lBAowCAYGBACRNwMAMAoGCCqGSM49BAMCA0gAMEUCIEcEziRRANDet2XFq2edSZu5jmZYLOQ1vBL5jQMjeuJ4AiEAmeJioo79n2kikncxdXrLNT+qlvL+3TNPt5oNBwHSsxo= + + + + https://www.nmhh.hu/tl/pub/HU_TL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + HU + + + application/vnd.etsi.tsl+xml + + + + National Media and Infocommunications Authority, Hungary + Nemzeti Média- és Hírközlési Hatóság + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/HU + + + + + + + + + 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 + + + + + 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 + + + + https://eidas.gov.ie/Irelandtslsignedv6.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + IE + + + application/vnd.etsi.tsl+xml + + + + Department of Culture, Communications and Sport + An Roinn Cultúir, Cumarsáide agus Spóirt + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/IE + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.fjarskiptastofa.is/library/skrar/tsl/tsl.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + IS + + + application/pdf + + + + Electronic Communications Office of Iceland + Fjarskiptastofa + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/IS + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.fjarskiptastofa.is/library/skrar/tsl/tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + IS + + + application/vnd.etsi.tsl+xml + + + + Electronic Communications Office of Iceland + Fjarskiptastofa + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/IS + + + + + + + + + MIIFUjCCBDqgAwIBAgIQEK7utqGYkEyYnrNc0XlTLzANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCSVQxJjAkBgNVBAoMHUFnZW56aWEgcGVyIGwnSXRhbGlhIERpZ2l0YWxlMRowGAYDVQQFDBFWQVRJVC05NzczNTAyMDU4NDENMAsGA1UEAwwEQWdJRDEhMB8GCSqGSIb3DQEJARYSaXRfdHNsQGFnaWQuZ292Lml0MB4XDTE2MDQyNzA4NTM0MloXDTIxMDExMjA4NTM0MlowgbQxCzAJBgNVBAYTAklUMSYwJAYDVQQKDB1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTEvMC0GA1UECwwmSXRhbGlhbiBUcnVzdGVkIExpc3QgTWFuYWdlbWVudCBPZmZpY2UxGjAYBgNVBAUMEVZBVElULTk3NzM1MDIwNTg0MQ0wCwYDVQQDDARBZ0lEMSEwHwYJKoZIhvcNAQkBFhJpdF90c2xAYWdpZC5nb3YuaXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQf3nLh9d4BwwuuF4Z0m9APKF+SqYc+nySjnyqNDevHc4989STgw4StRaI+QWr7eYvV+qLv9KKR57zfcOib37zKVGmdaXx33S3iy3cxLms2xtjvz2/YYOqdAaWdPP90VnnoSXndaGDb1RUgeisHiHfC1LZEdReYE9j4jVCwg0C8QHafKnBCXU5oKGl0BHLvc/1hhvglz3JqpF1TvJjcucHLRUoX4psJabWVhsBmb2+cFAO5PQIUDz1FbLY6hPcnRhp6CDkyTCztITfg4R4SegaXc9MXGGl0z+xHoDhd0LQoxXFLC0ZaOgZGxz4wQRYmboILy/rbU82wTf/AXIYJ5BrAgMBAAGjggGNMIIBiTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIGwDAdBgNVHQ4EFgQUunUq6QVK5Y31PcP5ihoQKOU7jqgwEQYDVR0lBAowCAYGBACRNwMAMDkGA1UdHwQyMDAwLqAsoCqGKGh0dHBzOi8vZWlkYXMuYWdpZC5nb3YuaXQvY3JsL0lUX0NSTC5jcmwwgcYGA1UdIASBvjCBuzAKBggrBgEFBQcCATCBrAYDK0wQMIGkMDkGCCsGAQUFBwIBFi1odHRwczovL2VpZGFzLmFnaWQuZ292Lml0L2Nwcy9JVF9DUFNfQUdJRC5wZGYwZwYIKwYBBQUHAgIwWzAkFh1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTADAgEBGjNDZXJ0aWZpY2F0ZSB1c2FibGUgdG8gdmFsaWRhdGUgSXRhbGlhbiBUcnVzdGVkIExpc3QwHwYDVR0jBBgwFoAUEG5XowkBlDSw7RnJVsM45A8SYkMwGAYIKwYBBQUHAQMEDDAKMAgGBgQAjkYBBDANBgkqhkiG9w0BAQsFAAOCAQEAnsiB+TUDBkVMsqjT2RLMZgOEi/IJsJqK7YBvl1+1Piu5sKyuyeSJsTMPYJsraen284m1ZVC9qsog47QxAXL1K621R9kU5HMUSKiimbDvSOiHNnWWWLbabk+gzSxMPhxzFlLnGZ4hxKVrnfuIZJH0JibMNXq1S1WAEInq4iGUdYvegYLz8i946riCbSYUtB0GDbKn6KQlux/GR7nwaImetqZM4cHLmCxShn6wS1s1NaQjBsgwUtxq14PbFlaH0whmytWmL7sW52mAcyzhAbkxA80dPj+er7zz/GskJe5Rle3lzFKAKznhD3QYms84iy3UjnXeSuKSXQw10sKtbNVeSw== + + + + + MIIFUjCCBDqgAwIBAgIQN05etZHKmECSK/TenCUl0DANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCSVQxJjAkBgNVBAoMHUFnZW56aWEgcGVyIGwnSXRhbGlhIERpZ2l0YWxlMRowGAYDVQQFDBFWQVRJVC05NzczNTAyMDU4NDENMAsGA1UEAwwEQWdJRDEhMB8GCSqGSIb3DQEJARYSaXRfdHNsQGFnaWQuZ292Lml0MB4XDTE2MDQyNzA5MjA0NloXDTIxMDUxMjA5MjA0NlowgbQxCzAJBgNVBAYTAklUMSYwJAYDVQQKDB1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTEvMC0GA1UECwwmSXRhbGlhbiBUcnVzdGVkIExpc3QgTWFuYWdlbWVudCBPZmZpY2UxGjAYBgNVBAUMEVZBVElULTk3NzM1MDIwNTg0MQ0wCwYDVQQDDARBZ0lEMSEwHwYJKoZIhvcNAQkBFhJpdF90c2xAYWdpZC5nb3YuaXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDJtzPKirZAlfG2RjE+cA83AYSxJC4pgFZFhr750Z56bEZ9UjMTajcTBKg6VhZxRU+R2z6sbj2o3OV4s8eDhgK6MI66xC78CoTwQk0ths+oiobvSvPIGuF91NkbLR7leEurWnaYid8nWYDHX6ok5+p3wK/LTjnYIQok10DYl0f0BIGCPrMmRnZr1BKijh+XhmJLpPxiYSwMfxM6itJ2mSUquhN2BxxerB8nptD5o8UVrLKmepCMYycFAZ5qSf/GqMKUrh8Yy3GvDGJfxJm7vPqKcj+g/oCBIm0YOA24RieahqlZDLdmio57XqEFyV4E5ye6rjFPoKu2v9HxAgvn9MFxAgMBAAGjggGNMIIBiTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIGwDAdBgNVHQ4EFgQUAt+oGvjGL3RLbqTgdl6KPs3z/zQwEQYDVR0lBAowCAYGBACRNwMAMDkGA1UdHwQyMDAwLqAsoCqGKGh0dHBzOi8vZWlkYXMuYWdpZC5nb3YuaXQvY3JsL0lUX0NSTC5jcmwwgcYGA1UdIASBvjCBuzAKBggrBgEFBQcCATCBrAYDK0wQMIGkMDkGCCsGAQUFBwIBFi1odHRwczovL2VpZGFzLmFnaWQuZ292Lml0L2Nwcy9JVF9DUFNfQUdJRC5wZGYwZwYIKwYBBQUHAgIwWzAkFh1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTADAgEBGjNDZXJ0aWZpY2F0ZSB1c2FibGUgdG8gdmFsaWRhdGUgSXRhbGlhbiBUcnVzdGVkIExpc3QwHwYDVR0jBBgwFoAUEG5XowkBlDSw7RnJVsM45A8SYkMwGAYIKwYBBQUHAQMEDDAKMAgGBgQAjkYBBDANBgkqhkiG9w0BAQsFAAOCAQEBQnxvuiuL507lhU/KdytchoLNdPS23IUT8OGBnJHzDYzGEVsHuEEo7TVuqRNhKpTe/MmKVGLAL7LzaigcHYSngux0F+20fZCW3o8NOc9OQNz8K8XhrOLIuzmiPvHRgjluMWaVU6QZkHEJu0ncQuErr+cGCV41SniCSff4DeoFYZt4wqiFra2Lh9geUkFmGyw39vdGcub8k24xRQUZ3CBWylS9GxGCicr/gAGnlvFbt6byWd9xpytVG0pnwiIkG08dVwly/zW/Zka++C+xsbrcFBzivu8zQmyKGs4ykU5WoaSIL/U6jv1yxrR4pPhq73KfBCwojqAX2gJjxtlQX/q0Mg== + + + + + MIIFUTCCBDmgAwIBAgIQZTsBHXHnMEWLMsMhC1buxjANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCSVQxJjAkBgNVBAoMHUFnZW56aWEgcGVyIGwnSXRhbGlhIERpZ2l0YWxlMRowGAYDVQQFDBFWQVRJVC05NzczNTAyMDU4NDENMAsGA1UEAwwEQWdJRDEhMB8GCSqGSIb3DQEJARYSaXRfdHNsQGFnaWQuZ292Lml0MB4XDTIwMTIwMTA5MzQ0MVoXDTI2MDExNDA5MzQ0MVowgbMxCzAJBgNVBAYTAklUMSYwJAYDVQQKDB1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTEvMC0GA1UECwwmSXRhbGlhbiBUcnVzdGVkIExpc3QgTWFuYWdlbWVudCBPZmZpY2UxGTAXBgNVBAUMEFZBVElULTk3NzM1MDIwNTgxDTALBgNVBAMMBEFnSUQxITAfBgkqhkiG9w0BCQEWEml0X3RzbEBhZ2lkLmdvdi5pdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKxsC/kmEJJO7/hcupCbonzR0UBxgO2Qud6/M4kvAE1NyRdd6soE6wLFSUcIoZCw6by31ddfaNTJbFkevNDUS31u2ycsOqMobPm/uTOTNpDhMLrsncY5O8aSGNYYMVn9Og2AtDhYDdkqnWR4jigzgTSJ/Fk5PFJarFZ/tk+kl3jLvrI9qOP861yQ+QCc/I+C04ugcpDONwkoWukZJtHayVrOoUZwgQGHBVFeD4nFbdZFH33le9YHN9vg7lczdTbLsYhEJp0WUwMsewC/NuPJ/grpr7hj6UcM4h4qEC/eS5d63pZHnwXqvgMW1AN6P38sSbXdd+45hDDcxVBhQ/JH5M8CAwEAAaOCAY0wggGJMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgbAMB0GA1UdDgQWBBSGmjb0h4WtXP3TDc0Njk9qZcpSNDARBgNVHSUECjAIBgYEAJE3AwAwOQYDVR0fBDIwMDAuoCygKoYoaHR0cHM6Ly9laWRhcy5hZ2lkLmdvdi5pdC9jcmwvSVRfQ1JMLmNybDCBxgYDVR0gBIG+MIG7MAoGCCsGAQUFBwIBMIGsBgMrTBAwgaQwOQYIKwYBBQUHAgEWLWh0dHBzOi8vZWlkYXMuYWdpZC5nb3YuaXQvY3BzL0lUX0NQU19BR0lELnBkZjBnBggrBgEFBQcCAjBbMCQWHUFnZW56aWEgcGVyIGwnSXRhbGlhIERpZ2l0YWxlMAMCAQEaM0NlcnRpZmljYXRlIHVzYWJsZSB0byB2YWxpZGF0ZSBJdGFsaWFuIFRydXN0ZWQgTGlzdDAfBgNVHSMEGDAWgBQQblejCQGUNLDtGclWwzjkDxJiQzAYBggrBgEFBQcBAwQMMAowCAYGBACORgEEMA0GCSqGSIb3DQEBCwUAA4IBAQFLLVVR81eBCxGXEDtvpltOERl7r/WbolQ62qYd2YfRCf7Xj9Qb65ZayvVtb9XQLO3h6sGFpKZ5tyXiA9HVbt+om9J+ezxaYMhWomNntJ2oi8g2rk3DV9jhkBxTwLrkFjU9yQokHzFBE4jy9OBciktmGZ22EOL03CAQD0OVc7ukr9zI8ICw5DL5t/v8o86Stu3y1DuvyZ519xRNJ6CZTTYiaD9iFOHma+VDbUy4yzZ642Z2FnUxxLxZZAnjJe1iKND6OGApxnB512So63VFLtPTcC26js10j6MFR+A7evqbWsVZTx1mlA0uQIro7c/NbZodboJ27jqJwwnLcsBqyPZG + + + + + MIIFUjCCBDqgAwIBAgIQdoEx8tMJRESZrx3ITwK2dzANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCSVQxJjAkBgNVBAoMHUFnZW56aWEgcGVyIGwnSXRhbGlhIERpZ2l0YWxlMRowGAYDVQQFDBFWQVRJVC05NzczNTAyMDU4NDENMAsGA1UEAwwEQWdJRDEhMB8GCSqGSIb3DQEJARYSaXRfdHNsQGFnaWQuZ292Lml0MB4XDTIwMTIwMTA5NDA1MVoXDTI2MDUxNDA5NDA1MVowgbQxCzAJBgNVBAYTAklUMSYwJAYDVQQKDB1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTEvMC0GA1UECwwmSXRhbGlhbiBUcnVzdGVkIExpc3QgTWFuYWdlbWVudCBPZmZpY2UxGjAYBgNVBAUMEVZBVElULTk3NzM1MDIwNTg0MQ0wCwYDVQQDDARBZ0lEMSEwHwYJKoZIhvcNAQkBFhJpdF90c2xAYWdpZC5nb3YuaXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQN3R97HGAIkPLE0SZVMnIgQrG2gmfUvvbfDbvTpx2Ng1qHFV+gSo4cKwR5uP3qycCA2kAkR8HoSqE9t/UGz3XEbaFaBCvRXXGNhREYHnUTW3TcfS2lv+QhY5fug84wkeetEOBBGE81zio+sZVRzRT7hHak8sGv26VOzLW6Jgt6q4M+r+4Q6dGKde9bjQxnlL9CpWSadImrKXUog3ar7Diy7CLTtQoBI6FnYili2oBGJIh9rM3uHyWZ+2/ctQtl9GB2M/vCBixyoySG52j/HLzsxEAtwnnuOzKx3d3JoegGGotvoqg/+Lj/sB/EBpYU1o/jToLFyVa/V7Q+uuQwGYBAgMBAAGjggGNMIIBiTAJBgNVHRMEAjAAMAsGA1UdDwQEAwIGwDAdBgNVHQ4EFgQUAAiTuMDCn+3Th5/SnfZ9MbLpCM4wEQYDVR0lBAowCAYGBACRNwMAMDkGA1UdHwQyMDAwLqAsoCqGKGh0dHBzOi8vZWlkYXMuYWdpZC5nb3YuaXQvY3JsL0lUX0NSTC5jcmwwgcYGA1UdIASBvjCBuzAKBggrBgEFBQcCATCBrAYDK0wQMIGkMDkGCCsGAQUFBwIBFi1odHRwczovL2VpZGFzLmFnaWQuZ292Lml0L2Nwcy9JVF9DUFNfQUdJRC5wZGYwZwYIKwYBBQUHAgIwWzAkFh1BZ2VuemlhIHBlciBsJ0l0YWxpYSBEaWdpdGFsZTADAgEBGjNDZXJ0aWZpY2F0ZSB1c2FibGUgdG8gdmFsaWRhdGUgSXRhbGlhbiBUcnVzdGVkIExpc3QwHwYDVR0jBBgwFoAUEG5XowkBlDSw7RnJVsM45A8SYkMwGAYIKwYBBQUHAQMEDDAKMAgGBgQAjkYBBDANBgkqhkiG9w0BAQsFAAOCAQEBbM/KmjgWRWE05eorBsjURkwxrrpYiZTLTmTxHOPyKVEYp9qLs95ffAWBnCNnDVx/ZM5N2VLeUDnWL+eJMx6ohaS1Rfk0/+jnxJnThHU9LWdu6NdZIjh8cDG2NKwKMhGJmr2qKXn6vpmV4GSTAJT0Y3C6utpGVxyuJz7oyNayqiXilLWghIq4LBAgrt9iIvykSTvGkvqtRP6yhq5h41lzRhbpbdryZcdDirqlrakPHqMpbeZYybWhu9yfTrPJ5ws99cRDLOOoNNVqjbmxfc240B/aCf+U4zLPjP0IAb2EY4e45YBURdho+xhLX6bUL7GgZsynnTx2089HJPqKmLqeqg== + + + + + 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 + + + + + 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 + + + + https://eidas.agid.gov.it/TL/TSL-IT.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + IT + + + application/vnd.etsi.tsl+xml + + + + Agenzia per l'Italia Digitale + Agenzia per l'Italia Digitale + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/IT + + + + + + + + + MIIFsjCCA5qgAwIBAgIJANWyu7iEuYtUMA0GCSqGSIb3DQEBCwUAMEoxCzAJBgNVBAYTAkxJMR8wHQYDVQQKDBZBbXQgZsO8ciBLb21tdW5pa2F0aW9uMRowGAYDVQQDDBFUcnVzdGVkIExpc3QgQ0EgMjAeFw0yMTAxMDgxMzAxMDBaFw0yNTAxMDgxMzAxMDBaMEcxCzAJBgNVBAYTAkxJMR8wHQYDVQQKDBZBbXQgZsO8ciBLb21tdW5pa2F0aW9uMRcwFQYDVQQDDA5UcnVzdGVkIExpc3QgNjCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAL+Y6ZqL7bhTsNXRoYsFvruazEUl25rV9nutBanfo8oV1J5wUeY1j00g9qput5IDLo6UWJg3887TxIDNhpYk0RdOegqxXNt7SZRpqqvqUtWiQYaruhTt6aSagWkbop3qD5buXAHC4eTbhukQuATl9FhlSRTeGWGPvZRawe7e9Az2GaYj96zszMI8FZ4OweAH5fRJPSfIuffWEXQlo8TuAtmHVyZ1yMh2nFhEWaGhXwAJ1luyVE7CuwFVK+W6A+bK9xNyVSh8Ej6NnBQxazffr/AcTVraph3ugU3Sjrdhc1WbofGt0aJtRMWWA1sX4jXDWPrBQCGxCus+YOLqriT7/wgIpIcb3BKpCML1Th+UOJ2WaOr25uOrY0u0NWzEbUzu++XopSG8zIOFk7seXlGKMxNrLtFNyYhIByXN0Ek/6dY3e1vafcAPUB+Y5hq/2kWpbVqDVP9ekWCSIekMD1NwlIulzKSFAe122fg85FXp90We8Op/Krph6JoJxl4rddljAwIDAQABo4IBHDCCARgwHwYDVR0jBBgwFoAUxtpl5ueSfdn8EJWUO/Ym9dhkhnEwHQYDVR0OBBYEFM2aoogULIODXECTyumQGfqn5f7QMA4GA1UdDwEB/wQEAwIHgDAXBgNVHSAEEDAOMAwGCmCDNgoKAAABAQAwCQYDVR0TBAIwADARBgNVHSUECjAIBgYEAJE3AwAwQQYDVR0fBDowODA2oDSgMoYwaHR0cHM6Ly93d3cubGx2LmxpL2ZpbGVzL2FrL2NybC1sbHYtYWstdGxjYTIuY3JsMEwGCCsGAQUFBwEBBEAwPjA8BggrBgEFBQcwAoYwaHR0cHM6Ly93d3cubGx2LmxpL2ZpbGVzL2FrL2Nlci1sbHYtYWstdGxjYTIuY2VyMA0GCSqGSIb3DQEBCwUAA4ICAQAfC+AnfNQlCCjsWv+WBzVLd9JL1h9jbyXOn1hAR09c8r8Rrf1Fb+Wn6t7oBYKOUogRHki5D5bbb9+kYOq7f2fxYg+vcGJ9M1Cpxh4F9yFgSvkfj/Vw8iRa3BPbiot7kRvQ//xdsZeTyR+YbeCvTbpmUd7HjzAhphCPf9tMgsacfrI97dsALGl+6YNYREnA2uLEF8ttDl0IM1MdmZ4QT/qpJlIpYhIxxiFvAjvlb84xWdtfzYhEwAtxYzTUg6h8L85d42oTTMQ8NeTXquhBSFlKywAHcfXMAHKX4kpEhazh/fqzhVS0EmOL1Mcanb977qPLxLtbSBY4l1TPnx/k7qYlf/MBwSvaAdDsx2NwczcvgH/NVkreIIIakQfjm00ZV+HMA2laUgtbJYETLecaVrURObjEP+wfNt5EhuQaVLXc2uaj8WR19x8/yfP3OUQntqz3eE8iAc5y25z35Pz11ylf6y78wmBKe3qcuOAS36KLj5MJHbLaMY6CUigFrny7zNATW7zaIxBwNt4mCF/fHGa9DsZIeV5UkzYDt3E21ucsLnBn/0uuesalcR8LpljdU3DqH+mLbMYtgXgPXWAdJkmpW9uKEyGffHnaYrpKTRqRWtDCdiHD6DAlZL4IPDl7iM1XFQPj8fSN90xf25qMDa7cBthf7KYgZjiSQ2xN8kByJw== + + + + + MIIFsjCCA5qgAwIBAgIJANWyu7iEuYtVMA0GCSqGSIb3DQEBCwUAMEoxCzAJBgNVBAYTAkxJMR8wHQYDVQQKDBZBbXQgZsO8ciBLb21tdW5pa2F0aW9uMRowGAYDVQQDDBFUcnVzdGVkIExpc3QgQ0EgMjAeFw0yMTAxMDgxMzEwMzFaFw0yNjAxMDgxMzEwMzFaMEcxCzAJBgNVBAYTAkxJMR8wHQYDVQQKDBZBbXQgZsO8ciBLb21tdW5pa2F0aW9uMRcwFQYDVQQDDA5UcnVzdGVkIExpc3QgNzCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAMunfVthxSbtRlcNSAGMAkkCok3s+RFI38KlP9RQ836qeEY/UANdp28WcocVpp47Vrr3AqfJ10mr26hodQriY6zJIeR57hCVJNaOWat+qT/jvLV8Gq/IaXZb0t0BbPVDW2bWHQMnP1E6UuD4IVraRP/YZE3z4WJusG+9t8AyerJZnY7SVHSJfZiSZzILBZzQ7PK2W594oISuxxh5y+jKt2h8jT25kKVN9sMR9JP3uHb31LIjXXTyHNZFyhHj/u3d3zvxcvarZKMgCEJJ0fvY8wOPHCbKX3WTbrTmLjRSlKOhto1Jvt/vYsbPKf0On3DEXjrDAXxV1Aw42wEvCtxBtUuxiGcMgfNq0c0l/qGJ3jGKpFBYhl7k5bA9ZJae7j0eQ4PF6pL5BWMk2sOB1kXiQzTzGaUAwqkpubsxzD/Kycsz1QzuHErLG7M8BkS3h9ge3XvsdHw3ni9IOH3ZWy4y1Ftl+56duLQwkavwZz/u0UE9fKXWPecxyN5G+ku/Tjc10QIDAQABo4IBHDCCARgwHwYDVR0jBBgwFoAUxtpl5ueSfdn8EJWUO/Ym9dhkhnEwHQYDVR0OBBYEFI6L90PcfHcaLVzJF7TZarj024kSMA4GA1UdDwEB/wQEAwIHgDAXBgNVHSAEEDAOMAwGCmCDNgoKAAABAQAwCQYDVR0TBAIwADARBgNVHSUECjAIBgYEAJE3AwAwQQYDVR0fBDowODA2oDSgMoYwaHR0cHM6Ly93d3cubGx2LmxpL2ZpbGVzL2FrL2NybC1sbHYtYWstdGxjYTIuY3JsMEwGCCsGAQUFBwEBBEAwPjA8BggrBgEFBQcwAoYwaHR0cHM6Ly93d3cubGx2LmxpL2ZpbGVzL2FrL2Nlci1sbHYtYWstdGxjYTIuY2VyMA0GCSqGSIb3DQEBCwUAA4ICAQBNhdWj1i2l6M7KOOZMcMIIVlGhxh4vHkHeeIGdSGJID2h9InQdgvE5BOq8cTiY2PiEtRkK6fhCfQl7DsPcb3aikt3DD9XDmONkt1XEjJ0fYjSsWq75BDtmxWEyCGwDqULfKKQeigHFSD2gZT0wOuXpn98M0qlrHSp0DbZE+h4ea8tl6OZJXdvc/cDKQo5nzyP0MjwRBNcIVDb+m8vsauLkD/+LsB2TS3nGk8oW+QlUNm27RLQ3scD/oZRvaqJdIr3F6wtOWIrIk6tKHWGUQoJxMtiV1P4itlrhlwzG341dDsK3ZOM+TFlJx0nmc0MS3Ay54qHLk66loxCEWDrLDRVg4r//SV8hIGlVpQd1V/jpDj83/tFNoKOsccwnB53dE/+776OmBYTp52Ee2ub+P+1GhhZmDm70WBl9o4jYf4Vc5Sa4UGSO8zm5FfPk+O/6hvSY/yLq96gWm4LAjooJ12+USaX/oQJMClNPtt1wV4hZWZLM7NBGSXd9yltDSUrTz3kdi+N8lpUAB6xWPtSUxMMNj+adCKh3tgHnaK4aeyAuB2gzWa9eQN2REcFzlSfrVAQCbe+UliAFId9DAKC/ucQrVvUUgeMdP4CKBNDTsh9ZqKEESgKEc/8nc839rO0bwgAT1PJtxwdrRKeNNcXlMHTPE4jAZ1cQuHS1XiIvwTHP0A== + + + + + MIIFvTCCA6WgAwIBAgIUWYfQNmYtVM/i0XC58kyqNbS6uNIwDQYJKoZIhvcNAQELBQAwSjELMAkGA1UEBhMCTEkxHzAdBgNVBAoMFkFtdCBmw7xyIEtvbW11bmlrYXRpb24xGjAYBgNVBAMMEVRydXN0ZWQgTGlzdCBDQSAzMB4XDTI0MTEyODEyMDYyMloXDTI4MTEyODEyMDYyMlowRzELMAkGA1UEBhMCTEkxHzAdBgNVBAoMFkFtdCBmw7xyIEtvbW11bmlrYXRpb24xFzAVBgNVBAMMDlRydXN0ZWQgTGlzdCA4MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAuYRnM8ispVhg/ojMqPi+LxpRHDWIR4QYnKhoOMxY2DdI80MJB/YZlgNEu4c618GS3MGXsOaZxXLbMlerpT5YV1jaROF2E4Yzsy4Ag4rzWxP9V5AelPLy9OEb+ktOy/pn/NHshzllzXH4Rw1tIJrboAALXQQNGAwtNFeEym2OzMAZoFQzTuXgmZXxhyLJpOV5A0fIsiwRbHNvAnwCCPMZhFxL8akxFOJhr6NTvWZBqXV36hxa40ssSQYyPfBj7R2S1zyt1cpS2VVhwBSMMjtWJRuVDeOsOamGzl+Ht+4e4ZN91JcgTmWGexnY4AfcbY70Hp8Q824Z14KKCtINEFIVTz5TJ493s/URAGYxV5autPWpE4+PeBXurk5zQ/ueC7JaX+/IieHl089H0v0ujbURgqQCGYqNcKKZFJm2ZlNpdIQW4ahVIxEp6OOg3xYEQKbm7sX0yHEzTsaFrvustdScpGtsZQ6HvyZD6OO9DHYtu8BU/mFIppLPDVGAjFIxNoCPAgMBAAGjggEcMIIBGDAfBgNVHSMEGDAWgBReNLw46ixAPtvFSoqTiBgyRDCnMjAdBgNVHQ4EFgQULhSirHsRPRUVX2FFWxpaILjPfqgwDgYDVR0PAQH/BAQDAgeAMBcGA1UdIAQQMA4wDAYKYIM2CgoAAAEBADAJBgNVHRMEAjAAMBEGA1UdJQQKMAgGBgQAkTcDADBBBgNVHR8EOjA4MDagNKAyhjBodHRwczovL3d3dy5sbHYubGkvZmlsZXMvYWsvY3JsLWxsdi1hay10bGNhMy5jcmwwTAYIKwYBBQUHAQEEQDA+MDwGCCsGAQUFBzAChjBodHRwczovL3d3dy5sbHYubGkvZmlsZXMvYWsvY2VyLWxsdi1hay10bGNhMy5jZXIwDQYJKoZIhvcNAQELBQADggIBACslEdLXgQadhzM5Ub9yHDQREZEfxXxvfMrFRDrJZwrztn+Xhr4rnZjkU1PVsHD39l7IeoDDm9rdMzyXeWBGQq8Iab7B3KvqOZIDuvblg14b2rjolvBz1ffuB1gSV54Mb0OALaJ7e670zhOt9IOwBRgPs/Xc7BZEuoL8bbcH5x8g7aLrT5JSeTfdTJtBdPnBMJqdjls1PUbfp4kxxrseL4H2dSELggXX7We1WFFt0rpzyX5iFjXhuVfRH4G/UB/npp9WUUB45Cy33cg1aRhEKgFuiTYqx5hmpp49iG/cvTlQ9ou3kWZgUMv3B+j8a9ZFDje5gy+2mFDb95B16Uimb54E7i7YoLJTZ5H8fhGXluyrd/KJvq69Dvvgq/pXjZQWU2byMgINaMJLlKmu3kIH0o/NrEhdMgcw3ZPwvW68mFBXL/lt0vtraPMDeTc5AluIHAmKDtiCY2vkP8j7Sr17h2pZVvnlRcNMJwNAf7h7yjH/IqHJsojbgUmV0dALFMfwHUVSKRaHQ0Sa2ZUvbNP6cCoY7LM2sRhCM7D/9PRPvMzLWFRqN6ndt4Y2iHUIuCekGL/VZVU3AyKc6sBfbqEgSbIthMcf3ofCUifBn1SbaIcydsgbkhQtIyqPK22XZTGjjF29G5qI8i30I+lEDTHyJ5ZNmSs0I+mklWtd54hnZ10b + + + + + MIIFvTCCA6WgAwIBAgIUSAY9IgLhjUS4ibJ7G5iAH5nZZ3cwDQYJKoZIhvcNAQELBQAwSjELMAkGA1UEBhMCTEkxHzAdBgNVBAoMFkFtdCBmw7xyIEtvbW11bmlrYXRpb24xGjAYBgNVBAMMEVRydXN0ZWQgTGlzdCBDQSAzMB4XDTI0MTEyODEyMTA1NFoXDTI5MTEyODEyMTA1NFowRzELMAkGA1UEBhMCTEkxHzAdBgNVBAoMFkFtdCBmw7xyIEtvbW11bmlrYXRpb24xFzAVBgNVBAMMDlRydXN0ZWQgTGlzdCA5MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA4Z7ZVoIRDoqquyfdPuX05HjZzEsO1fp6PdiYoGCH/MOEyMOIEl9/qPuWOzTEVgnXnfTxUxoFuvPBV7on5qKRO0pd8PzS6A8Y60afGsp5RNdiZBP4f3Fzpi1qLx5jTZrnne7VUX2lGfWRWf+On+1orXiwqu2yohLIehonrQXpMl1+AY2i7QRbdDk3aP+hKisuqCw03O7ECf4myDk1KOyOgnfiVeaRHx9gwOwNR7VmQ1isYSWaegoTSUZGmIIZCv6ki3E0vd9RDqlV2aWZG3HMo1EppC1bs7SFQ1VCeGpoK9dgUaHeiqkPkm1KS/NisFR+ZsQY6u7d6NS9sZYQh7FXNmTNq8TmcUGZqBhInKhhH1f9CdsKoy0E/s7hSje1VlhTE4DBdamX8myoCxkchmoZ4KuKdNKXl/SvnNpUv5VJ21oe3MJedfie4Z2czdbTi8eF6mcEuBNmUyElePSGuE7TZ0GvH+Z2dnJfD2hz4Zu4fQQWrzmlR684kFPSf9k2ZQdPAgMBAAGjggEcMIIBGDAfBgNVHSMEGDAWgBReNLw46ixAPtvFSoqTiBgyRDCnMjAdBgNVHQ4EFgQUgrE7HkUcdBzTtYNxhXCQoTaIAYgwDgYDVR0PAQH/BAQDAgeAMBcGA1UdIAQQMA4wDAYKYIM2CgoAAAEBADAJBgNVHRMEAjAAMBEGA1UdJQQKMAgGBgQAkTcDADBBBgNVHR8EOjA4MDagNKAyhjBodHRwczovL3d3dy5sbHYubGkvZmlsZXMvYWsvY3JsLWxsdi1hay10bGNhMy5jcmwwTAYIKwYBBQUHAQEEQDA+MDwGCCsGAQUFBzAChjBodHRwczovL3d3dy5sbHYubGkvZmlsZXMvYWsvY2VyLWxsdi1hay10bGNhMy5jZXIwDQYJKoZIhvcNAQELBQADggIBAHxV540BT2u5nETUrE5H6ukpcGmvivQ/hVwt9gWQ5Y5nufVesv0nVGEFDglPY/wKPi1J66aC919YvRWKlmEOZKQ9KjXNppfRAaDHR7BlGGWKtUOj5Jf9zDyIpfn76+7LSFgSxkJRurqQvaFNkFN59A1ErgT+7NgdjRAzZa7e9XMMav50UWtaTtr+pbnY8gYoRh14lp2BKnnvudqyso0LjqQvhlOtTPqrtnoS1DVRomv6bF4x9PjUicuo6pp2Ub86REz7fU9Qvr2q+qte0dvYiE+Lf5yacj28TR+2otuu421BkMNDcMs22ykB7Weyjij6l8hR1JEj9qU68cIBheI8hjNFCM0/0/ckj+KtiAGsdkyRFx5dbytp4ME4tt9n+An85fzyINgmUgCSHNUMzhr5SybaytSbUT6bcqRulTEsv4hGA1AC8u6ETNQQG+XRyMPZo+d+pbeJl+nWWO3Z401P8BPKnsLan4cApCRgacSF+Wpzkq1x3IUkLYcIo2rlDaqYsfk9jlRMU2826G0Uyf9J3Vj0LLljl7WOeZLPtICdoLNc1SHJpIOHB8pqOKw1MYD6sJ9DJUP69ysDopVA99kYW7rnuZAVTZAjcIOpoGvlAO7HtCmsYsBrEvIx5RoW+j6V7+2NXV8ZrIhwzTk8WWnwPgihEWjL7eXQ2LViiprd2sEy + + + + https://www.llv.li/serviceportal2/amtsstellen/amt-fuer-kommunikation/trustedlist-li.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + LI + + + application/vnd.etsi.tsl+xml + + + + Office for Communications + Amt für Kommunikation + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/LI + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + + + + MIIFAjCCA2qgAwIBAgIFEg8uSr4wDQYJKoZIhvcNAQEMBQAwdzELMAkGA1UEBhMCTFQxSTBHBgNVBAoMQENvbW11bmljYXRpb25zIFJlZ3VsYXRvcnkgQXV0aG9yaXR5IG9mIHRoZSBSZXB1YmxpYyBvZiBMaXRodWFuaWExHTAbBgNVBAMMFFRvbWFzIExhdnJpbmF2acOoaXVzMB4XDTI2MDEyOTAwMDAwMFoXDTMwMDIxNDAwMDAwMFowdzELMAkGA1UEBhMCTFQxSTBHBgNVBAoMQENvbW11bmljYXRpb25zIFJlZ3VsYXRvcnkgQXV0aG9yaXR5IG9mIHRoZSBSZXB1YmxpYyBvZiBMaXRodWFuaWExHTAbBgNVBAMMFFRvbWFzIExhdnJpbmF2acOoaXVzMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAycJkxaDDCxpvbW0o2SBaItOGCQRBKP5SgqC751aWSLVo7dwfSnGmY2RBzFAweAXGljiMr5Vf4z55qhypfiDyPj+QaFDi/6vy2frPKs25c+C67QozyxZPHCi/hBWAzYioyI0IB27rtK7lEk3NyXLrsRyk9t+0bkPsnJPZvw8U1JHVqJtx7p4A8yjmz2bWpvUw/wVVF/bFKtWUtQ55QzecSePvlJUBPNlyPM3+TSyLrR68fqUi6iysPY9cXtOTsgPu1EL5JSQu3d04tac0tGzyoNsmjf1NPWDJdc4LyA0vHNwyaYI32HNG/gQ3iZlqLsPy48NELbbZEZbYHktY3wB4iIiv+7zT1lFpO3WU8JX3l1AHtmqwMRzutWvc2NSY+2MVAs/EI91iGDPvw1+1S7sC8vSGUyUb/uXAUqCV+jJ7zg+K3diRk652nKFHyPqQhfG1S36cB5LX+XU03yBapSr1zSQg//Tl21r+eECZjoUkkGnKIGK+RIV9fSaaefZeFKNPAgMBAAGjgZQwgZEwHQYDVR0OBBYEFIGV2Btuiz3KtI2beR9Dsi0PIrd2MAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADAlBgNVHREEHjAcgRp0b21hcy5sYXZyaW5hdmljaXVzQHJydC5sdDAbBgNVHSUEFDASBggrBgEFBQcDAwYGBACRNwMAMA0GCSqGSIb3DQEBDAUAA4IBgQC0RtXCfUY9dSHKGxrEUtTr3P5kJ/DwnGpWeNDUXYxGSF2atpbhh+F6imL8ORDtBfevXc64ULFzdmTHfmv9LSaoTlx7IbpVkbDGjIlSfVE69EeswJ5/jDK6VNAcZjlrkIjEHIzWezI+I+mDWaumcgbY1GDXlvOb/fzDu6Glw2qhNB97HrCw47v5XI6BTkeMoFfCdLBktNZbLWx+GIcYqbQ88QFgOeQeQByovzaEZ3qlAn1g27mF3dHzPRe3ktmHxrcN21w1fUgxnv18u3cL7yzPGDT9vyRNre4h8cEx96jRnaSmj0On4v1EeMHZDxuXJvJciNV/B4KngyzYKEMuqNIkXrdgU/wH0mfSlKOvcHsFM4d7S93Un92kABaNxhTxmRBSrF2TgxZJTglP3vc9n0dVhjR5HnYxwdnay/YRuYLS5KB+cxBH9qQiipU9yUT9F/nwC2PVL6AzU2Qzsp/Ut7BShOCNcOzC6WhyjnknRuw4pu4hyZdlFw7wEJp4bAW//0E= + + + + + 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 + + + + + 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 + + + + https://rrt.lt/static/files/LT-TSL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + LT + + + application/vnd.etsi.tsl+xml + + + + Communications Regulatory Authority of the Republic of Lithuania + Lietuvos Respublikos ryšių reguliavimo tarnyba + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/LT + + + + + + + + + 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 + + + + + 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 + + + + + MIICjDCCAhOgAwIBAgIUaLo3ZSTI6j1b5dQbKzfhN/epMKowCgYIKoZIzj0EAwQwfjELMAkGA1UEBhMCTFUxEDAOBgNVBAcMB0JlbHZhdXgxDjAMBgNVBAoMBUlMTkFTMSQwIgYDVQQLDBtOYXRpb25hbCBEaWdpdGFsIFRydXN0IEJvZHkxDjAMBgNVBAMMBUlMTkFTMRcwFQYDVQRhDA5WQVRMVS0yMjk1OTQ2MzAeFw0yNTA0MTEwNTQ2MzBaFw0yODA0MTAwNTQ2MzBaMH4xCzAJBgNVBAYTAkxVMRAwDgYDVQQHDAdCZWx2YXV4MQ4wDAYDVQQKDAVJTE5BUzEkMCIGA1UECwwbTmF0aW9uYWwgRGlnaXRhbCBUcnVzdCBCb2R5MQ4wDAYDVQQDDAVJTE5BUzEXMBUGA1UEYQwOVkFUTFUtMjI5NTk0NjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATBSIwHyUDeq63bYo7RMX4JkbjUImjbBpblt5ioTpptvkoR1PyNojZaTnbWp1TzEwpehzzTYrwBN4uIE+vkV8Nue8PhJoh62iTDNXfYzfVZkou/ucqvC+SEB7lyn0JlhRSjUjBQMB0GA1UdDgQWBBSVtslX3RDZMeUu/A8f3QT8HcuHzTAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIGQDARBgNVHSUECjAIBgYEAJE3AwAwCgYIKoZIzj0EAwQDZwAwZAIwJbzVladMHwIBBctEoahSV6Jr+1HkgR5vmP05kJsOa7kI2gX3zIdaXTsSJi27D8qJAjAnWNhUIKphR8joW+3c17Lr7aYhiba1j+Qljv88ErCAGVohBURK5EhlYMqWo579/y0= + + + + https://trusted-list.lu/tsl.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + LU + + + application/pdf + + + + ILNAS + ILNAS + Institut Luxembourgeois de la Normalisation, de l'Accréditation, de la Sécurité et qualité des produits et services + ILNAS + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/LU + + + + + + + + + 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 + + + + + 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 + + + + + MIICjDCCAhOgAwIBAgIUaLo3ZSTI6j1b5dQbKzfhN/epMKowCgYIKoZIzj0EAwQwfjELMAkGA1UEBhMCTFUxEDAOBgNVBAcMB0JlbHZhdXgxDjAMBgNVBAoMBUlMTkFTMSQwIgYDVQQLDBtOYXRpb25hbCBEaWdpdGFsIFRydXN0IEJvZHkxDjAMBgNVBAMMBUlMTkFTMRcwFQYDVQRhDA5WQVRMVS0yMjk1OTQ2MzAeFw0yNTA0MTEwNTQ2MzBaFw0yODA0MTAwNTQ2MzBaMH4xCzAJBgNVBAYTAkxVMRAwDgYDVQQHDAdCZWx2YXV4MQ4wDAYDVQQKDAVJTE5BUzEkMCIGA1UECwwbTmF0aW9uYWwgRGlnaXRhbCBUcnVzdCBCb2R5MQ4wDAYDVQQDDAVJTE5BUzEXMBUGA1UEYQwOVkFUTFUtMjI5NTk0NjMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATBSIwHyUDeq63bYo7RMX4JkbjUImjbBpblt5ioTpptvkoR1PyNojZaTnbWp1TzEwpehzzTYrwBN4uIE+vkV8Nue8PhJoh62iTDNXfYzfVZkou/ucqvC+SEB7lyn0JlhRSjUjBQMB0GA1UdDgQWBBSVtslX3RDZMeUu/A8f3QT8HcuHzTAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIGQDARBgNVHSUECjAIBgYEAJE3AwAwCgYIKoZIzj0EAwQDZwAwZAIwJbzVladMHwIBBctEoahSV6Jr+1HkgR5vmP05kJsOa7kI2gX3zIdaXTsSJi27D8qJAjAnWNhUIKphR8joW+3c17Lr7aYhiba1j+Qljv88ErCAGVohBURK5EhlYMqWo579/y0= + + + + https://trusted-list.lu/tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + LU + + + application/vnd.etsi.tsl+xml + + + + ILNAS + ILNAS + Institut Luxembourgeois de la Normalisation, de l'Accréditation, de la Sécurité et qualité des produits et services + ILNAS + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/LU + + + + + + + + + MIIFszCCA5ugAwIBAgIQREON56Jz1XRnY/6v2uHdxDANBgkqhkiG9w0BAQsFADCBgTELMAkGA1UEBhMCTFYxOTA3BgNVBAoMMFZBUyBMYXR2aWphcyBWYWxzdHMgcmFkaW8gdW4gdGVsZXbEq3ppamFzIGNlbnRyczEaMBgGA1UEYQwRTlRSTFYtNDAwMDMwMTEyMDMxGzAZBgNVBAMMEmVQYXJha3N0cyBJQ0EgMjAyMTAeFw0yNDEyMTkxMTA4MzFaFw0yODEyMTkxMTA4MzFaMHExCzAJBgNVBAYTAkxWMTUwMwYDVQQKDCxEaWdpdMSBbMSBcyBkcm/FocSrYmFzIHV6cmF1ZHrEq2JhcyBrb21pdGVqYTErMCkGA1UEAwwiTGF0dmlhbiBUcnVzdCBMaXN0IFNjaGVtZSBPcGVyYXRvcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJ/A0ewgHlsdDanMiG+kN+ShkrWyN6M6v+JvQvvaRQLkt1StuDHbJw7RKcljZabjc2CYou6oZTu8mZkK6ps8VJZJ1DuuYwmPrENCkWI5flogM5dkNFzLhuSonoonqNEyJK344B/KurtKGiAHv1gG1U2nj9QETPPnq1CM2gz85mjk526azocFhmCnDOUZoawfwSmzV1B2VNVq0uik3ZUgk3WdWtwtiDwGPg36WDpaEOqXUdEdiePYsP6PaE5pgKnZDf2febs0u0wHC3c1k8EhuB8F4OZizE4mtS5AOxCehND0Ash5INkvYNnH3HcAkTVYxLAENUUahGR8PZcZFDb1NdkCAwEAAaOCATQwggEwMAwGA1UdEwEB/wQCMAAwEQYDVR0lBAowCAYGBACRNwMAMB0GA1UdDgQWBBSXG0PCnC4DR7s0WQ0ef0mKgFCG2zAfBgNVHSMEGDAWgBQZ6YJzV916YDK/6HQZJhX3rYD0FzAOBgNVHQ8BAf8EBAMCBkAwdQYIKwYBBQUHAQEEaTBnMD8GCCsGAQUFBzAChjNodHRwOi8vd3d3LmVwYXJha3N0cy5sdi9jZXJ0L2VQYXJha3N0c19JQ0FfMjAyMS5jcnQwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmVwYXJha3N0cy5sdjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vd3d3LmVwYXJha3N0cy5sdi9jcmwvZVBhcmFrc3RzX0lDQV8yMDIxXzE3LmNybDANBgkqhkiG9w0BAQsFAAOCAgEAW2dB1PN0Lrf/Upz+sV+07psL9B1P1ob7LPdYSAx6fPZyqywKTHsKyWqWbjxAHCMp8nPcuAEtlYjZ+Spc0RrfIVCbw/pasfNct48WMvkBJ86jZ+YgQlG5QcfK9cpBsPdf5He7/4GoxGM7nvEoas2tPs1foVGfBCsDUEhGj6Hwr7t8zwTtzglmUSMnnCTMiR8mLQPy8aXAB0D4w+06rsS3AhLRuRGb0aSyyFKW9x7X9JSyC1O9sF7D6y/sLa0ae1/VBUaJEgNBXH6UINdZEa05CYmblaUMHBarZpLlzOi7Fo+4lTV9e4gpOyw4q9AokmsVWYSna71GepoPQefGP1Pgy8Flv8fpk3Z5lSd45vKYPr/aUdnzbAcUfOv4PwLj/DL12wB0Phtwq/VC5P+PT9THJZx5VT4v10naDP1KoDr+SW/dcEwgVLWvDAtiA18cQtS5fP2eaMCciY8fn738DOzwq3NBIbpUkw9S/8wWEUHSir5bUhl2K/lo2kTsZ41HJBNY5OfgiHDwvz32xNYoExtyqXPiBxV4BJVxbZLmL92KYVJ24jaYoX1QE+4j3Vo8cu7EylK+ri+jYdGhjAEoGFCGS4BdS4W3hcYStyMkR9J3zmEQ1aiWyRwYqakinUhN+OPG4PQGybdGspQmjee442hTeQN/IVtuChqZMWatnEqmjuM= + + + + + MIIFszCCA5ugAwIBAgIQatqKHNZIHZZoLdAWeppTITANBgkqhkiG9w0BAQsFADCBgTELMAkGA1UEBhMCTFYxOTA3BgNVBAoMMFZBUyBMYXR2aWphcyBWYWxzdHMgcmFkaW8gdW4gdGVsZXbEq3ppamFzIGNlbnRyczEaMBgGA1UEYQwRTlRSTFYtNDAwMDMwMTEyMDMxGzAZBgNVBAMMEmVQYXJha3N0cyBJQ0EgMjAyMTAeFw0yNTA1MjExMzA3MzRaFw0yOTA1MjExMzA3MzRaMHExCzAJBgNVBAYTAkxWMTUwMwYDVQQKDCxEaWdpdMSBbMSBcyBkcm/FocSrYmFzIHV6cmF1ZHrEq2JhcyBrb21pdGVqYTErMCkGA1UEAwwiTGF0dmlhbiBUcnVzdCBMaXN0IFNjaGVtZSBPcGVyYXRvcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKFhax6zUwiAyx/OT4vDB9UAdg2PMoBYuhcJQQCUKXqcMo/j1RJ3Md4rma0QjcJEIG2Ol81sLh7ejznNATG3/XZP7cg+EPTzYpnz+pn7jSY2nA7DfYRRr0OPYYgTAepDRtAV06+cpcwviB//IdjY2MIFpdykmd6BfwKLYHZkARLXSKADyZf310+DD5VBw+9br4jEAXanGS/aqHvKEGONpVB64nP4PZ69ulSYgK/MVJ0avmkbt/avdMInXm46NSHP6tHMOPA+OeWdKvv+FtpypggNptV9+2vVA9nEVO2N4IaIOoDjX16PzLJIVilJ9Ms7ieKHN6fKTrR7LCFUCybqKNcCAwEAAaOCATQwggEwMAwGA1UdEwEB/wQCMAAwEQYDVR0lBAowCAYGBACRNwMAMB0GA1UdDgQWBBQJA+o53eFwHXGwHg8voH14TAiJhjAfBgNVHSMEGDAWgBQZ6YJzV916YDK/6HQZJhX3rYD0FzAOBgNVHQ8BAf8EBAMCBkAwdQYIKwYBBQUHAQEEaTBnMD8GCCsGAQUFBzAChjNodHRwOi8vd3d3LmVwYXJha3N0cy5sdi9jZXJ0L2VQYXJha3N0c19JQ0FfMjAyMS5jcnQwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmVwYXJha3N0cy5sdjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vd3d3LmVwYXJha3N0cy5sdi9jcmwvZVBhcmFrc3RzX0lDQV8yMDIxXzE3LmNybDANBgkqhkiG9w0BAQsFAAOCAgEAH/RXIOc+eiLkT+8S7a7aHJYpJLsM+AD+4w6cj9p7TTD78105KvuJoeq1VayE3vftSkBcDC94PzRZQiQZ9E9SvSGQtBHE63SocnXLF65vml4qGxUwH9AQ5x13vqKRSRB3WVCztiZ0t9E+zxYnxJzuS3G/j6ULAA9Wn7iVn0+KVUyHTVne0rQwyGK0prbCBm16nCbz1fwLiUnR+jnBqz6d72WEkLXS0TY3W7pev9YV1lp636urmHO+QKjKFlU23AVWOvuYvKFdZGRKFgB/lm66xtrrs0YAoIslb5QUKG6WHoi3oYsYu3IuYcZ51RFq7G7p41FYuOB1tS4OJcncrjiYKLeHcBKCwOo3HveDUkCcq681kSMsZZgIPrhiljXBvQKbFme4IdCJrfWLkmwL2bZoXPt+8PkUkVrtc66Hw4MyXq8YHBpAid1JjefXRgXgV4IcFoW10s8ypAlSdbvyU4veMyPQ7Bx7A/TRG5K54mnKUnClP+fiL6FfLROyKlNbWDxQNP9WWDU9UWl0vwGJz9lVS9mL0cVPKePxDHPCPcTYAbQVEnjdnWoBzYozAVgI7Qrgzm1PBmWtdDIKskQgNzmQcpShXVtdWA9Z96w9HcIMX4VzJYb4mVng1/6zCbBV5nSBfvqOiwZQfHqAi0okrUAWeQhHxluAMMdY09mqH/hBbFo= + + + + https://trustlist.gov.lv/tsl/latvian-tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + LV + + + application/vnd.etsi.tsl+xml + + + + Supervisory Committee of Digital Security + Digitālās drošības uzraudzības komiteja + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/LV + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + https://tsl.mca.org.mt/MT_TSL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + MT + + + application/vnd.etsi.tsl+xml + + + + Malta Communications Authority + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/MT + + + + + + + + + MIIFyjCCA7KgAwIBAgIFFMyAj6UwDQYJKoZIhvcNAQELBQAwaDELMAkGA1UEBhMCTkwxLzAtBgNVBAoMJlJpamtzaW5zcGVjdGllIERpZ2l0YWxlIEluZnJhc3RydWN0dXVyMRwwGgYDVQQDDBNSREkgTkwgVFNMIFNpZ25lciAxMQowCAYDVQQFEwE1MB4XDTIzMDEwMTAwMDAwMFoXDTI4MDEwMTAwMDAwMFowaDELMAkGA1UEBhMCTkwxLzAtBgNVBAoMJlJpamtzaW5zcGVjdGllIERpZ2l0YWxlIEluZnJhc3RydWN0dXVyMRwwGgYDVQQDDBNSREkgTkwgVFNMIFNpZ25lciAxMQowCAYDVQQFEwE1MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAsTqqg974T6mHiWPNGv9IrVYFB+4fWJboTXx+ACNzcGehwqAfN3aSTawnJ95nq3rol0bK/8TePjeu2OjkZFBAhZyBzh99Hr0QEyj+qJGOErcX3ujbSOu9/MxtoUZHCVXLChecm/dLDgqnVGGUI0EJEP+rW/fu9uz30Mb2bvTuCiWxa369LuntFFlALOo5OxTfdOEj1V7ubcdqyGVroUn/ePyTpaqOhD8el293Zv3qfi2y0t05IyngrbV2rDFk7Y5++pyXhlgxck9UbKv9clHkb5hzW7JS2CJaFo3PRo5dEWmYYc9YayvioRkI6BaoYypXXTuUc9Zu9A2jMS6ACG+cQwU48K0ZvQDWBopvJJ7kGc+PCmwWluUs0ECzM/HQq6pRNfw6ZUR0q/7xANPCU5/2VYKIEb7I/3HZC4v4Q0iu30QXltUmQQTIBjzX7ZYX3ZQFr8FCrGRwPmAgwCNvRGR+y2/vykYQTTZ1qcoubzhiJZvFSfRrmVz155nMOHGiY4R8xkM7rbEeE+Zjglg7OfvWIp/ecgNVhnUm+GAJnOZw5e337nsGigHMGlbCi1pBtw0f1+5jMN90QemamoC7xUn0xbbdH3p4tvxZbuTlcLwVB44OvVvTqQTBiWVX+u0gAPUpUzUKTb43wj0/vxKOFb7PZWiI3Lhrl5pJ6Sju6lnhwFkCAwEAAaN7MHkwHQYDVR0OBBYEFISge/8g59F7ILYOZoaJ252V5+8kMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADAXBgNVHREEEDAOgQxlaWRhc0ByZGkubmwwEQYDVR0lBAowCAYGBACRNwMAMA0GCSqGSIb3DQEBCwUAA4ICAQB31upkefX2Mty4o8REJ25aIj7kvSPzBfRIFuOrN9wFSzcddLNwIb2XZT55qZdTmXGh+gtipk881yvMQKYgz5g1LwijAJkAe6BlIyXM8XLIR44ktCvu+BWiTXt+mevGnHn65i56TQEpfGLzryl7tXnn3dvv1SowXkraL1piTsC6aPWNMdgmZp5wqHldQYN/Y/MkmMN7bla2TLQGLl7qxVRpZ/QXC/90gKXfxtKCrmVbwF2ezwa5u53bCXdSYqd+1gTCMdbmRYqYkJN1gSlmMtHWmPRtmPDMms/TanQXhkVepz71xfhFiaz310aF8jFhApxqhVCpK01Pd8Crg0LNaF97DeNBbOS6i9L6dDVFjM00vE6AbLaQCcc9XL41cTUoaarGaUkZJf3mOWUFWDrGP7gStyxf8k0a1NpoPCe7UZesqrDiyU4UPxgBVo3XfXXOJLp12GKiHJEGOTSi8dj6JkLQVPLJjU/tVXm9MsGXCH2LSoYeWf9R5l8IviO+qtcvUUP/rEw2uYM3bDxecF8ZNGAE2oL1M1kJQs+GJUKQ/U2nPzrIdQ9icx4Kedr/1sPgYmARNE6MCg+hHIzXqmsgnL6+uMtX290vQOnK2rmBeWESP5RNcXGKMA1dlF/OvEigVC3FXA9FS8tkskF7ls53yCrPhcbgBnztWTXosF0lkXyM7A== + + + + + MIIFyjCCA7KgAwIBAgIFFIL/ecswDQYJKoZIhvcNAQELBQAwaDELMAkGA1UEBhMCTkwxLzAtBgNVBAoMJlJpamtzaW5zcGVjdGllIERpZ2l0YWxlIEluZnJhc3RydWN0dXVyMRwwGgYDVQQDDBNSREkgTkwgVFNMIFNpZ25lciAyMQowCAYDVQQFEwE2MB4XDTIzMDEwMTAwMDAwMFoXDTI4MDQwMTAwMDAwMFowaDELMAkGA1UEBhMCTkwxLzAtBgNVBAoMJlJpamtzaW5zcGVjdGllIERpZ2l0YWxlIEluZnJhc3RydWN0dXVyMRwwGgYDVQQDDBNSREkgTkwgVFNMIFNpZ25lciAyMQowCAYDVQQFEwE2MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAwaN627juutYUWCRlPXAHHSBXbq4ReJ9+FGRHbQ4axiLg4bxRRsnihACPFU6BijUHahaIjznffGh3PMDDqtVQLu9CxZdKc0QQEVtOGmZYR5rFqdw4FyPBOIHABEJOpN0RMErTcqUZGJvRp0komkzYHdb2S9gsetAsf1O2iq2CGlD6lU859wZU04EZYLSm+eb6O3hdF5KuYbHr2xu5oP4UOZWMv8yk3seg+Fv394P7BQvRQKU9KIp70B95ho7QsAbc5rYze5lzMqIQT8ciaZIYpTc99HIC/MmB/VwYM3VNAR6xmfkEPs/gZ+Ifz9/VmgX0NwFT55MsxrtuvHqD4yUSp87ulcnnuefxMd5np6ND2aUHlqA64Hj4G3nkzTtx+NNTzwjMZxZoodFNeOdjXs/KscSiC8PDUv/htAQ8nrHkpBOAWU92cBOz16LHRVOIsGNbsXbjSjQCbr1azMU7RBtDQ8HxlFZmXQ41nGl7K75BMlX5VuJXund8et+kbfik+XvZaZIFHKlIOZc+Q7EPl4QfTI3K/A27iLG7yITjJe3HOLh+LSU1VE9dlsHGehMEBGV2y4QHr6GweWA/LXrvuwCPlOhN40Au6DD8KN6bLaNuzIi/UfBhqEDELFJiS4rCHm03yi7ga9Prw9RbHXARw3ooSnEPcQYe+AWeUFvu6C6aTGUCAwEAAaN7MHkwHQYDVR0OBBYEFNE42SCJ8tnrD0ZYHxQFumRFc2UJMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADAXBgNVHREEEDAOgQxlaWRhc0ByZGkubmwwEQYDVR0lBAowCAYGBACRNwMAMA0GCSqGSIb3DQEBCwUAA4ICAQBtYEqNFv7vD2+17bdI4kXydD3vVEoYrvt+O/YBveP1IAfpRSkOGYOS5IvASHq5tYGfsIn8tRn9cEy0y333l1blSn4EN8abuKZC37FENBMBlNQuiMoXBqUYT6CwRUsNNbd1W3+eXm5GrvISihl003ztZlmf9QaKRZGUY1n1/2NpsJGpsOE6H0L4q/2tjtqWp2T4bVb4auwfMMt1k+IZ1998Ce7npy2Q2goM1XMFHVCQUJcddIx9c92Tx3he0MSjvQRaVIRDrzQhmkcLD5+skYza/N+dafz53SSD+5Tb7OG/Yl1ugwx7IdxS4tS0G2yrBnKzQohQ6AAmXf/inmnKrFoFg7pJQB/unUMe0gSM2wdlkoCHtbrb7JAbl3Pst3hC3IAR5GlF3PZ+JbMs12XneAFyIs5JiFW2XdDAOnCTB978QbWwc4kRvMcBS5//cNXo3vvinIDQWF7i3XyfDjpDNOCbiLUSGvko7TIODEGBkNPU3Uk1ZrwDVsRgLJQEgOplELDgN0HwXfp0G5ZIdnnroMnqFwDVjygjw9VkDW33oyjRr2QAI0aM3elT4jXrJbQCmL2So8GMxDS/OREnQCAkjGQa6TC0dRv8b4PBpcuhQnOIwM+j3CEEJrlqycABr7ItrYUc+hiyPXZCNWlx2TeYRAFMWI201vDLeqQvBebH287tiQ== + + + + https://www.rdi.nl/site/binaries/content/assets/site-content/bestanden/current-tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + NL + + + application/vnd.etsi.tsl+xml + + + + Rijksinspectie Digitale Infrastructuur + Dutch Authority for Digital Infrastructure + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/NL + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + + + + MIIFzjCCA7agAwIBAgIKB1uVj7q4nA3LUTANBgkqhkiG9w0BAQsFADBoMQswCQYDVQQGEwJOTzEYMBYGA1UEYQwPTlRSTk8tOTgzMTYzMzI3MRMwEQYDVQQKDApCdXlwYXNzIEFTMSowKAYDVQQDDCFCdXlwYXNzIENsYXNzIDMgQ0EgRzIgSFQgQnVzaW5lc3MwHhcNMjMxMDIwMDcwMzUyWhcNMjYxMDIwMjE1OTAwWjCBijELMAkGA1UEBhMCTk8xKTAnBgNVBAoMIE5BU0pPTkFMIEtPTU1VTklLQVNKT05TTVlORElHSEVUMQswCQYDVQQLDAJJVDEpMCcGA1UEAwwgTkFTSk9OQUwgS09NTVVOSUtBU0pPTlNNWU5ESUdIRVQxGDAWBgNVBGEMD05UUk5PLTk3NDQ0Njg3MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKxGdUULZsTe/tqvhUmrcRewV4jfPMrjJWDa3Ddw92NC8i0YedmPHT2gj0GvmCGNkBs9/Sf/4LHUY7tD5RGqQAWPDdclEagWb6dmTKs8mAs1o0untXrf7bc6uZvVKDV/cKYzDWa8ujswoSklHtwpCg6NolXjcDod5HqzH++R+vRVuH80G0z2piNzckuJ7L0qKTamYI1g37VCH5FV3w1ljyvek0QT0Z/8sMBn6/V4jnVk6yssnebw0VmPOZEF/QjdkOvL30UuLCoxIfOtr5IV4/twX5h9SzBvR1qmPxq9EKzWoP1aZ7F0dyEwq3IyR4p4U1fg3KnLqqb3ZgyS2oHC/8cCAwEAAaOCAVUwggFRMAkGA1UdEwQCMAAwHwYDVR0jBBgwFoAUsJFqvU6NsgkZhKm2dq1C8mno+C8wHQYDVR0OBBYEFKIDoAkQmcDW91tjINUxEYTYb85NMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSAEGDAWMAoGCGCEQgEaAQMFMAgGBgQAj3oBAjA7BgNVHR8ENDAyMDCgLqAshipodHRwOi8vY3JsLmJ1eXBhc3NjYS5jb20vQlBDbDNDYUcySFRCUy5jcmwwbwYIKwYBBQUHAQEEYzBhMCcGCCsGAQUFBzABhhtodHRwOi8vb2NzcGJzLmJ1eXBhc3NjYS5jb20wNgYIKwYBBQUHMAKGKmh0dHA6Ly9jcnQuYnV5cGFzc2NhLmNvbS9CUENsM0NhRzJIVEJTLmNlcjAlBggrBgEFBQcBAwQZMBcwFQYIKwYBBQUHCwIwCQYHBACL7EkBAjANBgkqhkiG9w0BAQsFAAOCAgEAM8VBmkH2F5BwyWxxTjuBa5RBZGxqQZPPB7tR6pyhitzGbbp6wqK05dUpNAyjHulw8VCBDKz08Gsv0FWEBp2DR+tiaW/sv7TOkLXPJ4KouBWTj8TIsoiMRGs/Cusk7r3rTV0VxN8xNG/eaEMTergiVnsYB4i1tr7Uu0vbU82mzg+CMrUgZtelSuVbmko8hblqAbbr4+n2YiZxHAHcYVzpyMShaoqD+Ifs6AjF1bv0ExqcotnmW5fXACx4k7sFgqcfNATkoplUNHY6Y4/+5gGrP1CyD+TAn6u0ajjwM73DbHOPYUQWCPJdwJHg+uNMRtoF5qSdtVWNnZhViXOhNjyMDneSBrpFT98NlTAwu9pBwnMcIHl7vN0x0KTD+zJqOSL+91ur/VuqxTV8aXOIpcH+u/tDCfVj3RHkbKPWTNIC/BlD6NnMVmQYUUq5Lvj3nIfBk9bay+41EXXLLQEnZVWCE2Bk7b0xh1xR/6kQqsMZ0MgJ0Bf76DTd/ETDf8vZhE2c8Q5CxOMxrbDHQV1IN/TZ40tAHekDcNEp48lRNheM9qlWdituYg1Wm1TQ7uYaOlxOCh5GuTtv3UqSx+u/7t9gcdb3dg2FPdtx3NYpImZX0BYsjF8/JzGukGOlnzzQv3/HqjksILTOtzbje//CKyb1szM8p0gTZbJZ0DUDW1V+cKc= + + + + + MIIFzjCCA7agAwIBAgIKB/uV1dhO8lKAHTANBgkqhkiG9w0BAQsFADBoMQswCQYDVQQGEwJOTzEYMBYGA1UEYQwPTlRSTk8tOTgzMTYzMzI3MRMwEQYDVQQKDApCdXlwYXNzIEFTMSowKAYDVQQDDCFCdXlwYXNzIENsYXNzIDMgQ0EgRzIgSFQgQnVzaW5lc3MwHhcNMjQwNDE1MDgxNzI1WhcNMjcwNDE1MjE1OTAwWjCBijELMAkGA1UEBhMCTk8xKTAnBgNVBAoMIE5BU0pPTkFMIEtPTU1VTklLQVNKT05TTVlORElHSEVUMQswCQYDVQQLDAJJVDEpMCcGA1UEAwwgTkFTSk9OQUwgS09NTVVOSUtBU0pPTlNNWU5ESUdIRVQxGDAWBgNVBGEMD05UUk5PLTk3NDQ0Njg3MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKnRrVaeBnBMSTf1VNlyO3kdqI8oQ8qge6a/Boh2Hb61exGjqQomitrkNzhrqty4N38ql4LswdWIvPBYkDShOh2ubiEGRxIkqzgmD1ZT2bSEniHYX/qXgfN+7t3gsG2HEOzYEx8SLVxacjxtiGV55CPOyPXwVDEh8+QLV50+DWJ0C0rsCuMnYTguvgesyKZC6Lp6CxnDvCFqW2UVhZZyvIpY2A9zSpjrHaJ8SFr3PBlHUwiBbU0TA278ptA9ibx9viyzrCP4FgGF3W0QCkZ3ZYkB8XFXsW/gTrJhnBH7hrfZ27A4yO124ZQtoaoTYKSgAVtOuuBZwUyvUOOtK7Fl/p8CAwEAAaOCAVUwggFRMAkGA1UdEwQCMAAwHwYDVR0jBBgwFoAUsJFqvU6NsgkZhKm2dq1C8mno+C8wHQYDVR0OBBYEFFjfRsc4ScVId5UvZHAjHbfe8s2fMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSAEGDAWMAoGCGCEQgEaAQMFMAgGBgQAj3oBAjA7BgNVHR8ENDAyMDCgLqAshipodHRwOi8vY3JsLmJ1eXBhc3NjYS5jb20vQlBDbDNDYUcySFRCUy5jcmwwbwYIKwYBBQUHAQEEYzBhMCcGCCsGAQUFBzABhhtodHRwOi8vb2NzcGJzLmJ1eXBhc3NjYS5jb20wNgYIKwYBBQUHMAKGKmh0dHA6Ly9jcnQuYnV5cGFzc2NhLmNvbS9CUENsM0NhRzJIVEJTLmNlcjAlBggrBgEFBQcBAwQZMBcwFQYIKwYBBQUHCwIwCQYHBACL7EkBAjANBgkqhkiG9w0BAQsFAAOCAgEAUwibQXlcyu31jaQnIsrPmLm6ozbN7XvqhGRpRjelEgK0IWK4Gi0Rh4E7JP7MfhLCJvwPlU1gQ6uMjOWq6xhLNkgiNXOWmAKQfdx4DydljwLlAjbpLbi/K2fzWi55rJP3L3WRTiTSO7pWx3FsJDGcTagxL8E/pDbGn0+lyZ2JaPl2adVbMZDMPYF+hCxn6Nlx7XM8gKqTO4lIvF6lSUbnqiO+zCsmWq69lQUNbfnvS3eP2KLCHSoT24qbQnW5oD9/eMJOAGeqU/wrT6lW4pE/zT8ZfpPHLxQBsBQiEi/j+7ehISd5kRUCmWT9mGfb0eVlt8/RQ6q9JtmDyNIbq1tWNwiTS8B5GO+kzFIQqHKoKYRieK6BU2Aw/jMGeRxKmMkJv3fEDmt+Ys7EIqCVhG4y3LHERKroBWbETldsmLX5/ocUelqbax0SFmwPXnKepXRYfRWp7C9jEiSQElrsFGygWgULqrRjk/JbVTDiSQvPRPgtJQXGkbE2jHrQO4ib2pE8SlhLypFr7B9SKPW/5Lmb20To3cJV6ffe+cftCeYv0yZsbA0jVYdltSCNeWOob7dTpbFUKXU5zuUKZCgdVXfCKSrVux84j5Kkspkc9dGbnIkwaW/xDgVhwlDl3cPA9AwyDbwPgmrif0UkQmpN4lfGDrc1EkHDkfhddS7q0iSPFYE= + + + + https://nkom.no/files/TL/NO_TL.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + NO + + + application/pdf + + + + NORWEGIAN COMMUNICATIONS AUTHORITY + NASJONAL KOMMUNIKASJONSMYNDIGHET + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/NO + + + + + + + + + MIIFzjCCA7agAwIBAgIKB1uVj7q4nA3LUTANBgkqhkiG9w0BAQsFADBoMQswCQYDVQQGEwJOTzEYMBYGA1UEYQwPTlRSTk8tOTgzMTYzMzI3MRMwEQYDVQQKDApCdXlwYXNzIEFTMSowKAYDVQQDDCFCdXlwYXNzIENsYXNzIDMgQ0EgRzIgSFQgQnVzaW5lc3MwHhcNMjMxMDIwMDcwMzUyWhcNMjYxMDIwMjE1OTAwWjCBijELMAkGA1UEBhMCTk8xKTAnBgNVBAoMIE5BU0pPTkFMIEtPTU1VTklLQVNKT05TTVlORElHSEVUMQswCQYDVQQLDAJJVDEpMCcGA1UEAwwgTkFTSk9OQUwgS09NTVVOSUtBU0pPTlNNWU5ESUdIRVQxGDAWBgNVBGEMD05UUk5PLTk3NDQ0Njg3MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKxGdUULZsTe/tqvhUmrcRewV4jfPMrjJWDa3Ddw92NC8i0YedmPHT2gj0GvmCGNkBs9/Sf/4LHUY7tD5RGqQAWPDdclEagWb6dmTKs8mAs1o0untXrf7bc6uZvVKDV/cKYzDWa8ujswoSklHtwpCg6NolXjcDod5HqzH++R+vRVuH80G0z2piNzckuJ7L0qKTamYI1g37VCH5FV3w1ljyvek0QT0Z/8sMBn6/V4jnVk6yssnebw0VmPOZEF/QjdkOvL30UuLCoxIfOtr5IV4/twX5h9SzBvR1qmPxq9EKzWoP1aZ7F0dyEwq3IyR4p4U1fg3KnLqqb3ZgyS2oHC/8cCAwEAAaOCAVUwggFRMAkGA1UdEwQCMAAwHwYDVR0jBBgwFoAUsJFqvU6NsgkZhKm2dq1C8mno+C8wHQYDVR0OBBYEFKIDoAkQmcDW91tjINUxEYTYb85NMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSAEGDAWMAoGCGCEQgEaAQMFMAgGBgQAj3oBAjA7BgNVHR8ENDAyMDCgLqAshipodHRwOi8vY3JsLmJ1eXBhc3NjYS5jb20vQlBDbDNDYUcySFRCUy5jcmwwbwYIKwYBBQUHAQEEYzBhMCcGCCsGAQUFBzABhhtodHRwOi8vb2NzcGJzLmJ1eXBhc3NjYS5jb20wNgYIKwYBBQUHMAKGKmh0dHA6Ly9jcnQuYnV5cGFzc2NhLmNvbS9CUENsM0NhRzJIVEJTLmNlcjAlBggrBgEFBQcBAwQZMBcwFQYIKwYBBQUHCwIwCQYHBACL7EkBAjANBgkqhkiG9w0BAQsFAAOCAgEAM8VBmkH2F5BwyWxxTjuBa5RBZGxqQZPPB7tR6pyhitzGbbp6wqK05dUpNAyjHulw8VCBDKz08Gsv0FWEBp2DR+tiaW/sv7TOkLXPJ4KouBWTj8TIsoiMRGs/Cusk7r3rTV0VxN8xNG/eaEMTergiVnsYB4i1tr7Uu0vbU82mzg+CMrUgZtelSuVbmko8hblqAbbr4+n2YiZxHAHcYVzpyMShaoqD+Ifs6AjF1bv0ExqcotnmW5fXACx4k7sFgqcfNATkoplUNHY6Y4/+5gGrP1CyD+TAn6u0ajjwM73DbHOPYUQWCPJdwJHg+uNMRtoF5qSdtVWNnZhViXOhNjyMDneSBrpFT98NlTAwu9pBwnMcIHl7vN0x0KTD+zJqOSL+91ur/VuqxTV8aXOIpcH+u/tDCfVj3RHkbKPWTNIC/BlD6NnMVmQYUUq5Lvj3nIfBk9bay+41EXXLLQEnZVWCE2Bk7b0xh1xR/6kQqsMZ0MgJ0Bf76DTd/ETDf8vZhE2c8Q5CxOMxrbDHQV1IN/TZ40tAHekDcNEp48lRNheM9qlWdituYg1Wm1TQ7uYaOlxOCh5GuTtv3UqSx+u/7t9gcdb3dg2FPdtx3NYpImZX0BYsjF8/JzGukGOlnzzQv3/HqjksILTOtzbje//CKyb1szM8p0gTZbJZ0DUDW1V+cKc= + + + + + MIIFzjCCA7agAwIBAgIKB/uV1dhO8lKAHTANBgkqhkiG9w0BAQsFADBoMQswCQYDVQQGEwJOTzEYMBYGA1UEYQwPTlRSTk8tOTgzMTYzMzI3MRMwEQYDVQQKDApCdXlwYXNzIEFTMSowKAYDVQQDDCFCdXlwYXNzIENsYXNzIDMgQ0EgRzIgSFQgQnVzaW5lc3MwHhcNMjQwNDE1MDgxNzI1WhcNMjcwNDE1MjE1OTAwWjCBijELMAkGA1UEBhMCTk8xKTAnBgNVBAoMIE5BU0pPTkFMIEtPTU1VTklLQVNKT05TTVlORElHSEVUMQswCQYDVQQLDAJJVDEpMCcGA1UEAwwgTkFTSk9OQUwgS09NTVVOSUtBU0pPTlNNWU5ESUdIRVQxGDAWBgNVBGEMD05UUk5PLTk3NDQ0Njg3MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKnRrVaeBnBMSTf1VNlyO3kdqI8oQ8qge6a/Boh2Hb61exGjqQomitrkNzhrqty4N38ql4LswdWIvPBYkDShOh2ubiEGRxIkqzgmD1ZT2bSEniHYX/qXgfN+7t3gsG2HEOzYEx8SLVxacjxtiGV55CPOyPXwVDEh8+QLV50+DWJ0C0rsCuMnYTguvgesyKZC6Lp6CxnDvCFqW2UVhZZyvIpY2A9zSpjrHaJ8SFr3PBlHUwiBbU0TA278ptA9ibx9viyzrCP4FgGF3W0QCkZ3ZYkB8XFXsW/gTrJhnBH7hrfZ27A4yO124ZQtoaoTYKSgAVtOuuBZwUyvUOOtK7Fl/p8CAwEAAaOCAVUwggFRMAkGA1UdEwQCMAAwHwYDVR0jBBgwFoAUsJFqvU6NsgkZhKm2dq1C8mno+C8wHQYDVR0OBBYEFFjfRsc4ScVId5UvZHAjHbfe8s2fMA4GA1UdDwEB/wQEAwIGQDAfBgNVHSAEGDAWMAoGCGCEQgEaAQMFMAgGBgQAj3oBAjA7BgNVHR8ENDAyMDCgLqAshipodHRwOi8vY3JsLmJ1eXBhc3NjYS5jb20vQlBDbDNDYUcySFRCUy5jcmwwbwYIKwYBBQUHAQEEYzBhMCcGCCsGAQUFBzABhhtodHRwOi8vb2NzcGJzLmJ1eXBhc3NjYS5jb20wNgYIKwYBBQUHMAKGKmh0dHA6Ly9jcnQuYnV5cGFzc2NhLmNvbS9CUENsM0NhRzJIVEJTLmNlcjAlBggrBgEFBQcBAwQZMBcwFQYIKwYBBQUHCwIwCQYHBACL7EkBAjANBgkqhkiG9w0BAQsFAAOCAgEAUwibQXlcyu31jaQnIsrPmLm6ozbN7XvqhGRpRjelEgK0IWK4Gi0Rh4E7JP7MfhLCJvwPlU1gQ6uMjOWq6xhLNkgiNXOWmAKQfdx4DydljwLlAjbpLbi/K2fzWi55rJP3L3WRTiTSO7pWx3FsJDGcTagxL8E/pDbGn0+lyZ2JaPl2adVbMZDMPYF+hCxn6Nlx7XM8gKqTO4lIvF6lSUbnqiO+zCsmWq69lQUNbfnvS3eP2KLCHSoT24qbQnW5oD9/eMJOAGeqU/wrT6lW4pE/zT8ZfpPHLxQBsBQiEi/j+7ehISd5kRUCmWT9mGfb0eVlt8/RQ6q9JtmDyNIbq1tWNwiTS8B5GO+kzFIQqHKoKYRieK6BU2Aw/jMGeRxKmMkJv3fEDmt+Ys7EIqCVhG4y3LHERKroBWbETldsmLX5/ocUelqbax0SFmwPXnKepXRYfRWp7C9jEiSQElrsFGygWgULqrRjk/JbVTDiSQvPRPgtJQXGkbE2jHrQO4ib2pE8SlhLypFr7B9SKPW/5Lmb20To3cJV6ffe+cftCeYv0yZsbA0jVYdltSCNeWOob7dTpbFUKXU5zuUKZCgdVXfCKSrVux84j5Kkspkc9dGbnIkwaW/xDgVhwlDl3cPA9AwyDbwPgmrif0UkQmpN4lfGDrc1EkHDkfhddS7q0iSPFYE= + + + + https://nkom.no/files/TL/NO_TL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + NO + + + application/vnd.etsi.tsl+xml + + + + NORWEGIAN COMMUNICATIONS AUTHORITY + NASJONAL KOMMUNIKASJONSMYNDIGHET + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/NO + + + + + + + + + MIIFaTCCA1GgAwIBAgIJAPkJD06+VcoxMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAlBMMSAwHgYDVQQKExdOYXRpb25hbCBCYW5rIG9mIFBvbGFuZDEcMBoGA1UEAxMTUG9saXNoIFRTTCBPcGVyYXRvcjAeFw0yMjA3MDQwOTExMjdaFw0yNzA3MDMwOTExMjdaME0xCzAJBgNVBAYTAlBMMSAwHgYDVQQKExdOYXRpb25hbCBCYW5rIG9mIFBvbGFuZDEcMBoGA1UEAxMTUG9saXNoIFRTTCBPcGVyYXRvcjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANl4s+Dyf/b4QN9rVmR4r0p7rWnJHf2KQsVFnqaWvx/OrQuwhUcPuzXMBR9CSRcckkXVPfRD/KEl0yiXpjadWzLUI6C85UIfBSn17nWsy25N4q5XjxzrD8xu1P9JDFiXmvNOl8s9pUgYJPKkRck52UQMr+ltVdH7tE6X/LiJ90X7EfU0tZTvTLd16ReI1UEJu54BUN1WziJ/ux7JVS0xUC0alNfwMwq7/VMADlrxSsFopKYTXBbwrr0mK7iVyqLoBJk4UOG7oG2m0r0HwtYQ9cnZSgDVII4tE9zII9uIr5Il7N8rRJBXPB96/5G0bONkPIiI5AshViL+0Z5YF2gOQNu7tedysSY5rzYprQ9KPFL9GlB2xV0YHNpDvKaP4/nZcubs+wGlFTHpJSiSEcTvybdt13qP+W8qCE0dYEfpUZirRX1E/RU5SiTfY7mMXOclQrOXcwzLTo3Avkh7j3Z4+ClJ5GvZdW0l50AurwoeJg0Rm8/Y1oFwrIIx8jHdx9B8mTkEJC89fCtBLpsBACKnstXC/OZsmBmevK+VWwO/P7xBxdrJPIeyh1lEVPcK23/AUlQpi4lZuwpiZ4cm0abErAsILhceQ0jMzy2ZFP35eiVUyAW/FuJTGVsBgw+hsgwUTuH7aJ9gY4n0xZWGvSBhSmDXnR8TYedfdetOKl12og0pAgMBAAGjTDBKMAsGA1UdDwQEAwIHgDARBgNVHSUECjAIBgYEAJE3AwAwCQYDVR0TBAIwADAdBgNVHQ4EFgQUDiu8pAOXGI+AjoQq6URCYPARuVgwDQYJKoZIhvcNAQELBQADggIBAAH932XnAA4tRmTX0SAE1tNM7Q7mPewm1pzgM6MfAnadh7YD9FEmuNoWXTX42FQlAL36JXahGVy2vApcBLJn/QQyE4mh7fGCUl+tRjpHAcwTyhbL9Wprfy1gyNc3h1DQCQggW3HlWwPx2Sz2nHVF4ui8Hc5nl1CPaCUtyT5KRJFvDc8LSTa9SFxVeSaQE5yJVwyUlVqmRyTDUUlbsvWtEd2EPDgPjPMl0t0cd0H/3YvyQbeRGDIfGN82Q96diNQFjaiWlnqMI9ylBumJ1rUepq+bBUvw2ZPJi//G4X6QVagC8FxCNU6FuuPEyWQleBYslVkV8WzLNsIsaDp8TcNnWfHYdWmV/3ufhJa8M2rtFoDYtjvuDNZi9XEwKFbguXIcbQ/H/EsqN5T+O6WYWmEeQoenZnCAwYLCuOfrXrugMMABkMfTpE8txyX7H0NTGXxq9l8CiAK9zg8fEgaaUFQpEZcW1YC+ntnDc6hyhhnLHZE7CbhJVFVZidZvuqo/3IwVyEUhKOt5uFmHvfasBksZKDuaZmQcQU0I2FHF6BdqufmRtkrVAIAQfdZezl0+VDJ469ZkWAoKQBpK7b0xsGX/t4CeXGmVbY4cTYpNI7chGs5QZ2iWKRZC/eEeXZ0UNKul7cmNIertLCDfJngZT7AyknwdsqZzho82HsSxkm3YeLXc + + + + + MIIFbTCCA1WgAwIBAgIJAMRAJBh13KZlMA0GCSqGSIb3DQEBCwUAME8xCzAJBgNVBAYTAlBMMR0wGwYDVQQKExROYXJvZG93eSBCYW5rIFBvbHNraTEhMB8GA1UEAxMYUG9saXNoIFRTTCBPcGVyYXRvciAyMDI0MB4XDTI0MTIxNjA5MTkyMFoXDTI5MTIxNTA5MTkyMFowTzELMAkGA1UEBhMCUEwxHTAbBgNVBAoTFE5hcm9kb3d5IEJhbmsgUG9sc2tpMSEwHwYDVQQDExhQb2xpc2ggVFNMIE9wZXJhdG9yIDIwMjQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDAvP2LaRM1HwpAmz/b/UO6bcu4eJWEaFC8CxDO1nYzj+vjuHHnn85UAhiWYqOQHhDTP6wk2sr32ixdfdUjHRgWgixCEkwIERR+3d6oFthyK8/oObD9y1YsCgeNheIxVuYVQQUUFHmFTHmYH6YVVG5S3ZR4iRL2+1rZcsO76c+W4TX9t04f85YineOGv00OCFAy0qV8i+TZjYAseZ9vtXH0g/u75zVA+pNDWjFr37VZGllo1KygNniJFBcP593SjHkSU0CX2dBWburXkrclE2cusNExpoAtGQesoWxjyes4m6R7cEA7fCoG9keekn7aTtkmNXqKkeEySyGdYm5SXbgQIyZu0UtVB0eB60vhMso0JLNuEBNp3HYo/vEArElo+m67mYln9S66J0v83JWzP5tCSkLzT3fYm+caX3AWb3XPBoUhWAZSik9UYbOMxaTZIzGOyOVdjBXlhTT5c0dumcYp36q9AY1lwzTVzojxgS+6TKz2fzR/IRSgU3iDFzdffECtRyhFSP8yPYIHfnrjb0+Az2DmZxShkezgQxc5ESHbNrovYYQWTTkuDz8sFBo5tnLtTEaacpEbmzePsdsIS0fR9DGNXePnNLKINdXYWkBJggjc4v57tRHdN5cInqTbcsclk+jUWXcAYY6WqwF9f7PIn7zfcKH6w/1l2JJ+7kJBLwIDAQABo0wwSjALBgNVHQ8EBAMCB4AwEQYDVR0lBAowCAYGBACRNwMAMAkGA1UdEwQCMAAwHQYDVR0OBBYEFO8luUKGxFWf0WuJib2ewmlpsRaQMA0GCSqGSIb3DQEBCwUAA4ICAQCsoQA6Ih68Uv+CjDy9Y3Vp8Mpob6TLqdGmV9dE3XTBtOj4AXecLQtXQUd0ueWRaoDfqx4KCbJl8EXtiba1mg/5AFH9U0JqoVUsl64di9FccRAvGNy8D1oZyIXZB+ye4NroYY5uazh+ujV4+rZ2BOLABINON/Ywp+n+SaSYwkD7mQyysW2469nSTLknVYSVabzEqjWtlDOCVyJLg5icQbZ01guN3CPII9Dy9wlov5jtG9UYCyGMDRQOHrNXu2Ie7q0Gi0zJH1hulqQWwUsOiXdfcgzS3yyboZFcxNE3NjKXwNSLKKPFNoZaQWug6Rh4WW/440P3/gxs88HG8a5xiwYIAX4M8hpmTdabUtHbqKv7f/RXZoUL5z3MBmonPLIg54OX/DPjHj1WqTNcgLeYXUdLS/0jnp2AZBQGeKdsJU5PbzV8B3/90cdhx9RH1sY9f/RqB2o4WSNDe6YpJWl7SSDrc+6t8Fy5P4gz01tB3MnHgndELniAA7jxArSQXl6y8h94kRg1mxit23kDLJGebY3tBcNz1Nq0+2vOR0/2tyxVD+qpJGvwsbM2XbWSkzv6FE+tlZZ6sKi2assT+1vDLpovm5VUay4Ji3RJJrLL8cKVC0EUFFgFR6xUEDKVMGAQPzFjyYCffVnrmXNrVXxHmsbvLeEN9bSBxW7ylL1ysDNPZg== + + + + https://www.nccert.pl/tsl/PL_TSL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + PL + + + application/vnd.etsi.tsl+xml + + + + National Bank of Poland + Narodowy Bank Polski + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/PL + + + + + + + + + MIIIFTCCBf2gAwIBAgIQUjkqe2lODeNqYOcjFGerFDANBgkqhkiG9w0BAQsFADCBgDELMAkGA1UEBhMCUFQxPDA6BgNVBAoMM0Fnw6puY2lhIHBhcmEgYSBSZWZvcm1hIFRlY25vbMOzZ2ljYSBkbyBFc3RhZG8gSS5QLjENMAsGA1UECwwEU0NFRTERMA8GA1UECwwIRUNFc3RhZG8xETAPBgNVBAMMCEVDQ0VRMDAzMB4XDTI2MDcyMjE1NTIwM1oXDTI3MDcyMjE1NTIwM1owZzELMAkGA1UEBhMCUFQxKDAmBgNVBAoMH0dhYmluZXRlIE5hY2lvbmFsIGRlIFNlZ3VyYW7Dp2ExLjAsBgNVBAMTJVBPUlRVR1VFU0UgVFJVU1QgTElTVCBTQ0hFTUUgT1BFUkFUT1IwggGiMA0GCSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQC13SYcuFt/CgqewEGIirRV08XbzuzQY+g9cLKeEakCRY0pyjozGGqDqfoVp6ncOfEIv1WycKaPkp7e6q3P4p+OQMgR3rlqrLMIDT3HNzrof6tqeWxrfI1XfKFhF9o0fUnpQ1FjT4TnXTwahkB9C038kMR/T+K/I8lRvFBjMDkc6KsQdRdYtALvIUQGasC9Z5UHvKzq9gXS9+uQ35QvbiRYnLWXEaA3+9Kdw+1j1vdEgBYmu8z8IprNBBg+MXOrNJb1t8OmxZkAQ6n0g9JBC+xnDoue+0sr0RKKfH2SxMjIA7guh8jMg2idlJpKX/mqJAUFqL9VTgMFDW4ZwTnQlU+CSz8qu3rbsojZAR9QHDnxw/9qStNeNL5bn2XCluaPyCvJ0JuQ4ho+0vBv4HekYbEm8nGZIZ+h19L0iHybMJxHpma5HmLY7K7s0wsASej66f1RJp4LKUNVeCNjGHd4c0ExpqWoUcLx26hLSJJNn7fzkQFstsTXmImrLkivD8HogOECAwEAAaOCAyEwggMdMAwGA1UdEwEB/wQCMAAwDgYDVR0PAQH/BAQDAgZAMBEGA1UdJQQKMAgGBgQAkTcDADARBglghkgBhvhCAQEEBAMCBSAwHQYDVR0OBBYEFKnh9hiBI3Xrquf7JNGnHGuGySz4MB8GA1UdIwQYMBaAFGOfMdTj/Pql056MNqGixlZMX+ptMIIBEwYDVR0gBIIBCjCCAQYwgfgGCGCEbAEBAQIKMIHrMCYGCCsGAQUFBwIBFhpodHRwOi8vd3d3LmVjY2UuZ292LnB0L2RwYzCBwAYIKwYBBQUHAgIwgbMagbBPIGNlcnRpZmljYWRvIGVtaXRpZG8gc2VndW5kbyBlc3RhIHBvbO10aWNhIOkgZXF1aXZhbGVudGUgYSB1bSBjZXJ0aWZpY2FkbyBkaWdpdGFsIHF1YWxpZmljYWRvLCBub3MgdGVybW9zIGRvIGRlZmluaWRvIG5vIHJlZ3VsYW1lbnRvIChFVSkgTm8gOTEwLzIwMTQsIGFwbGlj4XZlbCBwYXJhIG8gZWZlaXRvLjAJBgcEAIvsQAEDMIHbBggrBgEFBQcBAwSBzjCByzAIBgYEAI5GAQEwgZ8GBgQAjkYBBTCBlDBIFkJodHRwczovL3d3dy5lY2NlLmdvdi5wdC9tZWRpYS80MTkzL3BraV9kaXNjbG9zdXJlX3N0YXRlbWVudF9wdC5wZGYTAlBUMEgWQmh0dHBzOi8vd3d3LmVjY2UuZ292LnB0L21lZGlhLzQxOTAvcGtpX2Rpc2Nsb3N1cmVfc3RhdGVtZW50X2VuLnBkZhMCRU4wEwYGBACORgEGMAkGBwQAjkYBBgIwCAYGBACORgEEMGYGCCsGAQUFBwEBBFowWDAjBggrBgEFBQcwAYYXaHR0cDovL29jc3AuZWNjZS5nb3YucHQwMQYIKwYBBQUHMAKGJWh0dHA6Ly90cnVzdC5lY2NlLmdvdi5wdC9lY2NlcTAwMy5jcnQwOgYDVR0fBDMwMTAvoC2gK4YpaHR0cDovL2NybHMuZWNjZS5nb3YucHQvY3Jscy9lY2NlcTAwMy5jcmwwDQYJKoZIhvcNAQELBQADggIBAFZwIIHhHIOQsGbMMr8nZkCfymofGo2UQMsqBk6EGy21Rl5uNZ2jPSOO2ousRy6IYTDrG0q1QSYZWD/chD+zU3Sn3JF94CQ+3IVUoGewkdkbexzF7L/tyaBQd7bhLMqA10DtH/iVRi0rWrn66ivvPlYMTzxd1Lrw6aEPBWA/gLM5tNCe6J47xKyMXsZIh9+S31V+DhoR6sB9nvDn59ooZQSDWt5LEzlyGhoQiV+8jz4VQza6OpFeClg5BNN2lTh4oRfgaXuCJf/Dg97dRh5hKKgOXHfozd/GGuoIEWanHxJp+X1BW0eRugMusFBVUYhafVbDxrIBvGEHvsfVhnwxbt9ZTzxCEMXSYEJoxLDGf3sFSgVB7oFphCvIGKUIcnut/a8HKrm8VfvL8/WKuhv/HGSFLnmaAfC81azReHbJSQmU6Nbmpqyj9GVg95AGDXS1+VDDMTA6xzaQu2E5mc8ME+T2FJG4KHBs790o5PLeBmyvaL5Fo6b65YuoeVqglAFi9/F2EO+kB+xQo1lkoANIupsZz3U2pPN3Rb9sAToJN94/hc2hlzOA5GgkKXlq43pOosbQdSQwAK7Y/hmqJKP8eSoxGOwAqAeyS6mkJoN2eGubWzM6I2FtdUyyownscW0oTBmZIlIAbnJ7rn1KAFaIRfkT6pEjEvq8TVJvMejRGH5D + + + + + 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 + + + + https://www.gns.gov.pt/media/TSLPT.pdf + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + PT + + + application/pdf + + + + National Security Cabinet + Gabinete Nacional de Segurança + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/PT + + + + + + + + + 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 + + + + + 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 + + + + https://www.gns.gov.pt/media/TSLPT.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + PT + + + application/vnd.etsi.tsl+xml + + + + National Security Cabinet + Gabinete Nacional de Segurança + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/PT + + + + + + + + + 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 + + + + + MIIG1DCCBLygAwIBAgIUDiddqAHYhaLE9ZR3An2OsWwMH0EwDQYJKoZIhvcNAQELBQAwgYAxCzAJBgNVBAYTAlJPMRgwFgYDVQQKDA9UcmFucyBTcGVkIFMuQS4xFzAVBgNVBGEMDlZBVFJPLTEyNDU4OTI0MSIwIAYDVQQLDBlUcmFucyBTcGVkIFRydXN0IFNlcnZpY2VzMRowGAYDVQQDDBFUcmFucyBTcGVkIFFDQSBHMzAeFw0yNDA5MDUxNTUxNDBaFw0yNjA5MDUxNTUxMzlaMIG1MQswCQYDVQQGEwJSTzEyMDAGA1UECgwpQVVUT1JJVEFURUEgUEVOVFJVIERJR0lUQUxJWkFSRUEgUk9NQU5JRUkxETAPBgNVBGEMCDQyMjgzNzM1MQ0wCwYDVQQEDARTaW11MRcwFQYDVQQqDA5SYWx1Y2EgQW5kcmFkYTEZMBcGA1UEBRMQMjAwNDEyMjM1UkFTMTU5ODEcMBoGA1UEAwwTUmFsdWNhIEFuZHJhZGEgU2ltdTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN4eGt7EZnhPZD2qbbdVUud2Ca7KVfeJPDKJS5AM9zosgfQDEBygTBFfYtWpWJWRU8G/iOhtfWroJKSPPYyfxx46iiodanyaOYXVLaNAumqbVh7D2TAiLnX3YpeW2ajyltoXJcmd/NuaUx5tAIZnTVdCRAlaeySxfxLVvHHX5CL6IqG3fd51Gb52/qmD2dwZx+8DUmn5ZHrG4hBsUcqsSP0kzSiYDGuXBhOsmHE2SmLOOaxDOoFfAtt2bVVAWYD2ls5pJHynOgRVjFe+FqFhJfgmiwQkcX+iDqA3fwmwn2+9YL+bWLKUcnylJ0PADfxohf4B8omvOcEHJ7kQHOzXqYkCAwEAAaOCAg0wggIJMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUnwU7GTInyg5uFG7YYafwDflENLwwcAYIKwYBBQUHAQEEZDBiMDkGCCsGAQUFBzAChi1odHRwOi8vd3d3LnRyYW5zc3BlZC5yby9jYWNlcnRzL3RzX3FjYV9nMy5wN2MwJQYIKwYBBQUHMAGGGWh0dHA6Ly9vY3NwLnRyYW5zc3BlZC5yby8wIQYDVR0RBBowGIEWcmFsdWNhLnNpbXVAYWRyLmdvdi5ybzBVBgNVHSAETjBMMAkGBwQAi+xAAQIwPwYLKwYBBAGCuB0BAQEwMDAuBggrBgEFBQcCARYiaHR0cDovL3d3dy50cmFuc3NwZWQucm8vcmVwb3NpdG9yeTARBgNVHSUECjAIBgYEAJE3AwAwbgYIKwYBBQUHAQMEYjBgMAgGBgQAjkYBATAIBgYEAI5GAQQwEwYGBACORgEGMAkGBwQAjkYBBgEwNQYGBACORgEFMCswKRYjaHR0cHM6Ly93d3cudHJhbnNzcGVkLnJvL3JlcG9zaXRvcnkTAmVuMDoGA1UdHwQzMDEwL6AtoCuGKWh0dHA6Ly93d3cudHJhbnNzcGVkLnJvL2NybC90c19xY2FfZzMuY3JsMB0GA1UdDgQWBBQunOJgPw1t1xTHr8sUpw6AcE1hczAOBgNVHQ8BAf8EBAMCBsAwDQYJKoZIhvcNAQELBQADggIBAI857ToiaXi3cT65jWhtcEDlg7n23swPiTSx6kQ2q+eDrVMerrrAeCSrnHozMLz5jd4bfQNGLOq9LT2dy5WWe14tva2O081YXfJ8nB/7RlBMIR/M3qFvAz8HoBcfaqvZO3VHYtx4ygUMZ5vDdEHrOTZYWQT/hSqFjUviJwscrJwM6/s1clTJd9ghQewvz+Ao+KFt906czrM7PGc20T94TSNASqIxfLPaFiLbLeJOcKnl4uxTbM3JvI5KU/MxBHdN4yV3hDa1Z3PZbU44j5ArXfOT/W9M2ffvGtuXdXzUyMHWWopGyG+2se1oT5tE9tBtSJEP8mbHwReYsDhQP9cg8ehx3XrINl9KP2hY+4yQkmC++BaBnOAIjhyUYR7V4pcmDWvduvn3Jz/1jNkch/sDPdqzksOd9u2Jfal8lfHuLVihL5dEFyLi1whVDpWYkr0dYnOVMbz1ho/xH8rTpkdHlMIg8SaQURzDwsWtygLANsAgZmxto2eDLXHq7V6+rBV1U34RfFZ4lTprOxCUOKTBt9KXI1AooGt57W6Q+QGfWgdU3iWu3BIGAHfxrS4oQPgwP/f/hz4fhxsKoC5DC4C+zj2ijRY3CsPb5ziqxOIhr4iWoQbQbsqrWIFumgVlK/Y6Wso2CLrEWOOmeTTFtL9/HciVjJgeA54A62NGpHFDsIlu + + + + + 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 + + + + https://trustedlist.adr.gov.ro/trustedlist.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + RO + + + application/vnd.etsi.tsl+xml + + + + AUTHORITY FOR THE DIGITALISATION OF ROMANIA + AUTORITATEA PENTRU DIGITALIZAREA ROMANIEI + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/RO + + + + + + + + + MIIEBjCCAu6gAwIBAgIUIPiiRCTDfQdWUbb+wxM4dWcR8dcwDQYJKoZIhvcNAQELBQAwgZUxLjAsBgNVBAoMJVN3ZWRpc2ggUG9zdCBhbmQgVGVsZWNvbSBBZ2VuY3kgKFBUUykxEjAQBgNVBAcMCVN0b2NraG9sbTESMBAGA1UECAwJU3RvY2tob2xtMQswCQYDVQQGEwJTRTEuMCwGA1UEAwwlU3dlZGlzaCBQb3N0IGFuZCBUZWxlY29tIEFnZW5jeSAoUFRTKTAeFw0yNDAxMTAxNDU4MjFaFw0yNzAxMDkxNDU4MjFaMIGVMS4wLAYDVQQKDCVTd2VkaXNoIFBvc3QgYW5kIFRlbGVjb20gQWdlbmN5IChQVFMpMRIwEAYDVQQHDAlTdG9ja2hvbG0xEjAQBgNVBAgMCVN0b2NraG9sbTELMAkGA1UEBhMCU0UxLjAsBgNVBAMMJVN3ZWRpc2ggUG9zdCBhbmQgVGVsZWNvbSBBZ2VuY3kgKFBUUykwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDU0gU0qb0mNic9938lGYV8xweSkrdpkCpCjhfg4W/9U8XSlZzCIqvU5L8VPk1VC6sCM7uOXJu19U4o4GJ9K0FmZ3egI0v0/uhSYd41vQtGRfezjx56W2mIPCKifN5RT2uKsu15MbMCK4Erc3i/C9f/Ht7XI9IbztTCzKeOUPcZXUCSIVfVjNjrhCeEbFJHDFf400TyRQNjCoY5teS9oNx9vY/TpANTytI5HHTQga9+nkHoUMEOHOmZDLO7fvHF5XbEgFfx7tpLUhQ0Y6BEktw39rY1N8hhySffct/BBUqus7zzm3UCrTNsa9aM7YKK3sphLP/DJCdvSbDa4ABoM2yhAgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgZAMBEGA1UdJQQKMAgGBgQAkTcDADAdBgNVHQ4EFgQUaWKRXtqZNMHTxVFB11/tu2RCNxYwDQYJKoZIhvcNAQELBQADggEBAHESWVJpJB70Gk5xz5drmObnGxtztPZDQMXFuek01t5v07DeCspKWTs/wybSJnEM1y9tsQtJ3UvaPQf2Pec0rJUrxgB3PdfXyyxNgeUVPxquYK61Mech458IIIN33ai6Ui5isv0M+d2LY0pFD0XLgGi2vR76q3Hd5Vhg7ozeRgKMHhPsRPrRgG9yW06ytSiFAbA3LDM8fpN7AyUsRhKj8XbbFpKsEOydSOycA98KwlTEJ5gxPcIY7t/DUhqMB2JuUYI/ch+FJogkqx2ontY8jNZknghVS9hM5BjGbOGN8vnLrG3mYfL6rriUpW09OVhr/f+3O3bbuQS40gf0kE6v/Yc= + + + + + MIIEBjCCAu6gAwIBAgIUOzkTfz3FusEX4xAXgwcZ/M50a8wwDQYJKoZIhvcNAQELBQAwgZUxLjAsBgNVBAoMJVN3ZWRpc2ggUG9zdCBhbmQgVGVsZWNvbSBBZ2VuY3kgKFBUUykxEjAQBgNVBAcMCVN0b2NraG9sbTESMBAGA1UECAwJU3RvY2tob2xtMQswCQYDVQQGEwJTRTEuMCwGA1UEAwwlU3dlZGlzaCBQb3N0IGFuZCBUZWxlY29tIEFnZW5jeSAoUFRTKTAeFw0yNTA2MDMxMzEzMTJaFw0yODA2MDIxMzEzMTJaMIGVMS4wLAYDVQQKDCVTd2VkaXNoIFBvc3QgYW5kIFRlbGVjb20gQWdlbmN5IChQVFMpMRIwEAYDVQQHDAlTdG9ja2hvbG0xEjAQBgNVBAgMCVN0b2NraG9sbTELMAkGA1UEBhMCU0UxLjAsBgNVBAMMJVN3ZWRpc2ggUG9zdCBhbmQgVGVsZWNvbSBBZ2VuY3kgKFBUUykwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC51eNJziwSKI6P7qH8hNNe2QfPs+xMKBGl0qz3lfr6e8fiLWhHzzS/Tk8XrudUqwaXXrXJBOuZibHSdmvpUBm8E8ytwjTieeZ9+1wcVRB1t6vINoj1XinZcKfIxXhRPao7bJNAIAM9WXoaYv3viLy3Ag7LQ7ArATL5j1DMfUnQ4yVS0ux6tysj+bVUdyvEstRs8ZaXyHyAGTJlTDrnI5dnko0EKSxQt9qRxhTQF0R0XX3be3Qpjaf1QJDUYSbqmROLVsvhy4jvHLvnn6M1Iocj3YKyYHqdVUYpHnfzsjK1i9n2MoUsaz+qRi6PyjbaRf4qyC4DNvJEs5dD29e6c3U/AgMBAAGjTDBKMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgZAMBEGA1UdJQQKMAgGBgQAkTcDADAdBgNVHQ4EFgQUvYZ2D4cNzdpEAQGF5Dkyrw+5CdcwDQYJKoZIhvcNAQELBQADggEBAHHgmMreIQi29ugS6hXcGlRbQ4Ob3xrtNgN99XiVdLHgBp+WvCFSEzgTOvwZgmRTdcu5a2gAVBxVqshKCOa6qe80746JMKVwvI0/ed4ZbYZqxJTAMPPAp1tru50YfXewP44phNmu4HaUdab8KI5ZeF03LTzezzUtZRrMmShkoAvOMjDuylrybGYfL0P/g5I10Q+akPDmewNnNPRFkC3gqH6JAsnE/HlazuG6FghD/UsvWN3U9fB2CesLRmfQ2kJGs17oM3+QYZNr89yWnFogmz8CaNhKyeBM+3iCQpS2Zcucs1RA9tWmuF/19HIqf1imHctBKyhxYGjwEDEaNR6s11Q= + + + + https://trustedlist.pts.se/tlv6/SE-TL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + SE + + + application/vnd.etsi.tsl+xml + + + + Swedish Post and Telecom Agency (PTS) + Post- och telestyrelsen (PTS) + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/SE + + + + + + + + + MIIEQjCCAyqgAwIBAgIIRvPCP6JFF4EwDQYJKoZIhvcNAQELBQAwgbYxCzAJBgNVBAYTAlNJMWcwZQYDVQQKDF5NSU5JU1RSU1RWTyBaQSBESUdJVEFMTk8gUFJFT0JSQVpCTywgSU7FoFBFS1RPUkFUIFJFUFVCTElLRSBTTE9WRU5JSkUgWkEgSU5GT1JNQUNJSlNLTyBEUlXFvUJPMRkwFwYDVQQDDBBEcmFnYW4gUGV0cm92acSHMQ8wDQYDVQQqEwZEcmFnYW4xEjAQBgNVBAQMCVBldHJvdmnEhzAeFw0yMzA0MTMxMjIxMDBaFw0yNjEwMTMxMjIxMDBaMIG2MQswCQYDVQQGEwJTSTFnMGUGA1UECgxeTUlOSVNUUlNUVk8gWkEgRElHSVRBTE5PIFBSRU9CUkFaQk8sIElOxaBQRUtUT1JBVCBSRVBVQkxJS0UgU0xPVkVOSUpFIFpBIElORk9STUFDSUpTS08gRFJVxb1CTzEZMBcGA1UEAwwQRHJhZ2FuIFBldHJvdmnEhzEPMA0GA1UEKhMGRHJhZ2FuMRIwEAYDVQQEDAlQZXRyb3ZpxIcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCMRkbnlpiCBbCUQB3pOnU87TzGpvMM5frqIDyX0zP3rRMsvw/gxZIAah0AzJRJNyPbhf1WZkhdjTo5a7K7tsUhfEsgjmOHCugITuH8YWyBSM2c0owmdDc6qZYiQ/bbYkR+PVU9EstVsmMKUkoVpdIg3bAoU6jZYPf0UiTMDMLEgdKGmUQj4QF/gzFBU1BhIXDDp/qeOSve7zmlFhazEGp6lQTsXxIlwN323ZExjY2vuP9ebI4TV1A7zT4Mp3P9USsZXhww1cXrq8qs68tHIb1sy1/FtmJPDyNL0ADglqFNhXLFCX0+oRxltEWf/yWn9W9SpC8JdG9YmovzNhxmvd5rAgMBAAGjUjBQMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFH6Xmzvr9cJG6wnPzvT3dhRerb3xMA4GA1UdDwEB/wQEAwIGwDARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggEBACrGOVbp6rE/I8BkACuwf1H5HSSmx77dnZksCHblg9TU08eotYyZ4SvWk8l3ceAHyzrg2x2fgpPa5e5CxVm2QmKayP0jNT/JvRP87Pu8hRObiWPwEJRVT6u4smLoR6tuLQ89NvtKRgT2s6ol06UEvjjWpS3YTNg13nsFSId0hQ3FesDqbNAHdMYLaHTvps9j19zuV66gSvyHXEEQJKsvHNtbTiHy/V6jlhKpSP8/bPSwwHwBQD2yU/DXRzJNker1UX1fxBNwKvG1eMxw89fTRrxskwUwDPtuTCWo34EgeFxwDIFlJV9GcpFZmPaPfpn3kCabPq9vrx4j4CzDKtoYjaw= + + + + + MIICpzCCAkygAwIBAgIIMxrywce7aGwwCgYIKoZIzj0EAwIwga4xCzAJBgNVBAYTAlNJMWcwZQYDVQQKDF5NSU5JU1RSU1RWTyBaQSBESUdJVEFMTk8gUFJFT0JSQVpCTywgSU7FoFBFS1RPUkFUIFJFUFVCTElLRSBTTE9WRU5JSkUgWkEgSU5GT1JNQUNJSlNLTyBEUlXFvUJPMRUwEwYDVQQDEwxNYXJpamEgU2V2ZXIxDzANBgNVBCoTBk1hcmlqYTEOMAwGA1UEBBMFU2V2ZXIwHhcNMjYwMTI3MTIyOTAwWhcNMjkwMTI3MTIyOTAwWjCBrjELMAkGA1UEBhMCU0kxZzBlBgNVBAoMXk1JTklTVFJTVFZPIFpBIERJR0lUQUxOTyBQUkVPQlJBWkJPLCBJTsWgUEVLVE9SQVQgUkVQVUJMSUtFIFNMT1ZFTklKRSBaQSBJTkZPUk1BQ0lKU0tPIERSVcW9Qk8xFTATBgNVBAMTDE1hcmlqYSBTZXZlcjEPMA0GA1UEKhMGTWFyaWphMQ4wDAYDVQQEEwVTZXZlcjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLZu9wx7aRdkoD5qzhDN/Qhj8DK4MTIk0JmpXxT9YZz11vRm8kDG64BagHKrDT9VD9Jj+JSlDhQOKpZl9wlyeVyjUjBQMAwGA1UdEwEB/wQCMAAwHQYDVR0OBBYEFFYb1Ztp1EO8HcaINhyh7f5+U2tqMA4GA1UdDwEB/wQEAwIGwDARBgNVHSUECjAIBgYEAJE3AwAwCgYIKoZIzj0EAwIDSQAwRgIhALjP2xcxM8qztELubCrX/EkRTQkOa3TfYMaKPIG8mL9yAiEA+KvJshZCM9x/8VG7i/z+sJGdwz0WNx4W0WSxoICQ7hg= + + + + https://www.tl.gov.si/SI_TL.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + SI + + + application/vnd.etsi.tsl+xml + + + + REPUBLIC OF SLOVENIA, MINISTRY OF DIGITAL TRANSFORMATION, INFORMATION SOCIETY INSPECTORATE + MINISTRSTVO ZA DIGITALNO PREOBRAZBO, INŠPEKTORAT REPUBLIKE SLOVENIJE ZA INFORMACIJSKO DRUŽBO + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/SI + + + + + + + + + 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 + + + + + MIIFEDCCA3igAwIBAgIFFD9H/fswDQYJKoZIhvcNAQELBQAwgYUxCzAJBgNVBAYTAlNLMRMwEQYDVQQHDApCcmF0aXNsYXZhMScwJQYDVQQKDB5Ow6Fyb2Ruw70gYmV6cGXEjW5vc3Ruw70gw7pyYWQxHzAdBgNVBAMMFlRydXN0ZWQgTGlzdCBzaWduZXIgMTAxFzAVBgNVBAUTDk5UUlNLLTM2MDYxNzAxMB4XDTI1MDQwMTAwMDAwMFoXDTMzMDYzMDAwMDAwMFowgYUxCzAJBgNVBAYTAlNLMRMwEQYDVQQHDApCcmF0aXNsYXZhMScwJQYDVQQKDB5Ow6Fyb2Ruw70gYmV6cGXEjW5vc3Ruw70gw7pyYWQxHzAdBgNVBAMMFlRydXN0ZWQgTGlzdCBzaWduZXIgMTAxFzAVBgNVBAUTDk5UUlNLLTM2MDYxNzAxMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEApDjddVizt4f6yEj5CPwlcWFzchFVkz8sLxfIPKPVxWq5OEietBCbzJ9Kn7QhqozEqnXYGF9x3iULzgS7SXZDKW2CvSnmjgx19SgUQ04p1ybK6YUZoniYKLkiW6Tye5MbUzC3ARJFO5KphW+IYn6ZOaScWmS+TVRz/DRIxR76p/gFrdtHA4l24nAmwtmiEcPlouMBI8zau2TxLYpfFlUxiVLFa4ueaWOt5+WLVSu3/8aZ8TPfHEBGTT4Qw65rBkCVj9US6UgED9ZURr42g6OPtKlSHdp3PQmyFsZsY80QsMBP94K9nEYhigQekHpncsW9SEfLGArilrvaKFei073N+F44PZuSFlHE1DXQ4CsLXYUDaQieZDibHUw3ZAkzr6ouLoGOvD9DidAaGoVkE4iHYH98M+IrnkwvgmP5TOWvs8bNBYQC0GzQTOVo4TxN6nnCKXWzHpAZGbNgDG3UWItMHtLZTBH727GRe6R1B9KIqpY+C/nBc8FxlzQ0aq6ZxOw/AgMBAAGjgYQwgYEwHQYDVR0OBBYEFBFY5rJma48Bbq2TgHGkjS6OrMnrMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADAfBgNVHREEGDAWgRRwb2RhdGVsbmFAbmJ1Lmdvdi5zazARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggGBAF3ewHpgk322ht0lT9qHertoEN1OtxbjYBkenmT3cydyILB9nYLFBZ7TL5VjzRtDC+8XOtsJXGVVko9/fj9tL+KodnmDlOjlp/Ovzwejwvakr6Ev4d1sVEHH4NSfxZ715LExd+LgQBf+gVE8ziSY3Kek6Af88y/6MRAs2lLa8/OK6m3g0+rdGD0xFj88c0DwiFmkFho/WKCLNgdtUIAZcbhi0Ufs7JD9cF7/+pLEt9o9Vl9n95UR5DFs/Afoi4sMsmYjUBPqSsMs1Uz0hH1loo3ZiXJuzGzMF/PqQJDRNT0u+K4GbXYW3oX1enB26XGuArGRCQ1Es8Wp0QkS8SppeVcnTXEOQXJ2y8Oy2JKMcvfxuCiiGHzl9IpSeOBR7KLEe2/Vr84FPlBrRTw6KNHsN8JV+svtXnH28XCx9TuCEo151HfbzPfWM45U7yLbLW6zqgSh1/6sJiUcRh4Ro8ctzkEwDUlbHYDeHm1tSOrsfsbQ56SAt/3gr2vnQLqJ+AtoEg== + + + + + MIIFEDCCA3igAwIBAgIFFEBkr74wDQYJKoZIhvcNAQELBQAwgYUxCzAJBgNVBAYTAlNLMRMwEQYDVQQHDApCcmF0aXNsYXZhMScwJQYDVQQKDB5Ow6Fyb2Ruw70gYmV6cGXEjW5vc3Ruw70gw7pyYWQxHzAdBgNVBAMMFlRydXN0ZWQgTGlzdCBzaWduZXIgMTExFzAVBgNVBAUTDk5UUlNLLTM2MDYxNzAxMB4XDTI1MDQwMTAwMDAwMFoXDTMzMTIzMTAwMDAwMFowgYUxCzAJBgNVBAYTAlNLMRMwEQYDVQQHDApCcmF0aXNsYXZhMScwJQYDVQQKDB5Ow6Fyb2Ruw70gYmV6cGXEjW5vc3Ruw70gw7pyYWQxHzAdBgNVBAMMFlRydXN0ZWQgTGlzdCBzaWduZXIgMTExFzAVBgNVBAUTDk5UUlNLLTM2MDYxNzAxMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAlarWmFZjmcK5QgO9Yp6ED0N/jVynXIL5b+yrUD9Ce2JMeLvD+BkLNOZElOhmB0Hbu2NVVi03qItvpDSHO65YCvWg3uYuBQF+eaJzrus0O2ugqD7M2QWsJSf1Tq9oJYH76KXZx4oK4ee8WbTR3WUcmgucUEJN/DipVHELGJkw3pnE74SyiHqp4DgBM8sohlFE2DjSTXx2RU+/3C96rZZiy6958YBWbCwbkICYqDeYxrb5Vq2uCpXg7jZN35VUroIxTi7gNJuJ9J9AqWdzW0Ya9hPG9Sq331X8Ik3999S893TgRp6m+6CLkdtNXpb38Iw2gqD4PUu2EqRkAAs1gdgzmtOAposSWdw+eqprzHaTkydLGO9K48MHx6sup+mvqbCIPhvAmFHNhJqDSkl/1nEzHo9+0EmoeI2relHsMXSRYGDRB+GvkTg9AvCLFKyrdlGwWC+C41Hb75Wxu+jaTr6m+YaiEr3Ugah+KjIEtQcBV5eBKDXUE9Ixy3KbsGrXaWIRAgMBAAGjgYQwgYEwHQYDVR0OBBYEFDfQBjSuiF+/zrSVcnULj+/f6jZeMAkGA1UdEwQCMAAwDgYDVR0PAQH/BAQDAgbAMBEGA1UdIAQKMAgwBgYEVR0gADAfBgNVHREEGDAWgRRwb2RhdGVsbmFAbmJ1Lmdvdi5zazARBgNVHSUECjAIBgYEAJE3AwAwDQYJKoZIhvcNAQELBQADggGBACUI1IW6Hk8THL64SN1ZDq4wdxvghFhsVSW6esMr1DG1Fqd4JVIVqlVZhEz8r/hvxcYoabw0KvaFf3AZr74B4tinPUM+fnOAX8PHDO9beWSVvQe1Z9VsAVOPNimPggrLSufIdADkdpU6E44Zy5Xo9iBz31vGVPG3Igii9TPAcmaBGRuuPxN9ChxURC9TfAK3nL+WL+rKbP20rktKhrpRsqIbYdRS0LVyeyMBmr87bZY4OOTxW+wayjHVApTSURwFvJ7+WbhIrKRB5GUtdlcx3Bs0Tj9oICB3tOVCKCXtA9EgGjsEOFUTk1careWFaoGrS81h0X3nbZw3UTk+P1HKwmOzvqgOJ7P5YAzRzl0ozegxH66IP+fCBr15rnBclhbD+Meq45Bk8Q/q03f2AWEdbE5g15N/M9i3eGmsyLoMoDgPTSzE1n4IlJVh45f3GLAcAF9XOZMPZAUlbV/Zamsf/kBYqRUAmpwZIsFh3yBnY20yyUI05PajsX6vKfGqkcpoQQ== + + + + http://tl.nbu.gov.sk/kca/tsl/tsl.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + SK + + + application/vnd.etsi.tsl+xml + + + + National Security Authority + Národný bezpečnostný úrad + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/SK + + + + + + + + + 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 + + + + + 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 + + + + + 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 + + + + + MIIICDCCBfCgAwIBAgIUSOnGJxOHWc5N+Nk12eZPPCwr7ZYwDQYJKoZIhvcNAQENBQAwXzELMAkGA1UEBhMCUFQxKjAoBgNVBAoMIURpZ2l0YWxTaWduIENlcnRpZmljYWRvcmEgRGlnaXRhbDEkMCIGA1UEAwwbRElHSVRBTFNJR04gUVVBTElGSUVEIENBIEcxMB4XDTI0MDUwNjEyNDUxNloXDTI3MDUwNjEyNDUxNlowggFZMQswCQYDVQQGEwJFUzE9MDsGA1UECww0Q2VydGlmaWNhdGUgUHJvZmlsZSAtIFF1YWxpZmllZCBDZXJ0aWZpY2F0ZSAtIE1lbWJlcjEjMCEGA1UEYQwaTEVJWEctMjU0OTAwWk5ZQTFGTFVROVUzOTMxHDAaBgNVBAoME0VVUk9QRUFOIENPTU1JU1NJT04xKTAnBgNVBAsMIEVudGl0bGVtZW50IC0gRUMgU1RBVFVUT1JZIFNUQUZGMTIwMAYJKoZIhvcNAQkBFiN2aWNlbnRlLmFuZHJldS1uYXZhcnJvQGVjLmV1cm9wYS5ldTEXMBUGA1UEBAwOQU5EUkVVIE5BVkFSUk8xEDAOBgNVBCoMB1ZJQ0VOVEUxHTAbBgNVBAsMFFJlbW90ZVFTQ0RNYW5hZ2VtZW50MR8wHQYDVQQDDBZWSUNFTlRFIEFORFJFVSBOQVZBUlJPMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAveJV7goW3mvqJq2kMT0cnrkFAnT/lyzbgaHVvd5jEMHy6RyoI1Af4JTlOWSjC+6fsNzApFR1Tv3w8/WuSgjHTWfDnpqs20iJh979A5WwvfXuzcuUqeFFptdR/tJm/08TsTAD+CeA+rQo6K23B1xMYRwX/BNt/EL03Q/TOQj5V4uV3Kyf0945yu5gOhmrMs/RZCZ8M+iahwTaVktf+ZvhocSsPt+a2OuPI8IpTU+xIWAXWuQ+27Q7zzD0d6sqBdruDr16clFtZXWNRikm9q6pCOAOKG/myszeUuy++TPtQnI3+OQlTuyDXsz9UNKboQCF2SNmfRoeBxcx02tS/zUgPwIDAQABo4ICvjCCArowDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBRzSfFAHBQEfJoSf/ovzVxnIxjpFDCBhgYIKwYBBQUHAQEEejB4MEYGCCsGAQUFBzAChjpodHRwczovL3FjYS1nMS5kaWdpdGFsc2lnbi5wdC9ESUdJVEFMU0lHTlFVQUxJRklFRENBRzEucDdiMC4GCCsGAQUFBzABhiJodHRwczovL3FjYS1nMS5kaWdpdGFsc2lnbi5wdC9vY3NwMC4GA1UdEQQnMCWBI3ZpY2VudGUuYW5kcmV1LW5hdmFycm9AZWMuZXVyb3BhLmV1MF8GA1UdIARYMFYwNwYLKwYBBAGBx3wEAQEwKDAmBggrBgEFBQcCARYaaHR0cHM6Ly9wa2kuZGlnaXRhbHNpZ24ucHQwEAYOKwYBBAGBx3wEAgEBAQQwCQYHBACL7EABAjAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwQwSwYDVR0fBEQwQjBAoD6gPIY6aHR0cHM6Ly9xY2EtZzEuZGlnaXRhbHNpZ24ucHQvRElHSVRBTFNJR05RVUFMSUZJRURDQUcxLmNybDAdBgNVHQ4EFgQUjueweY4PI0KGjetMh84vTsEnxQcwDgYDVR0PAQH/BAQDAgZAMIHTBggrBgEFBQcBAwSBxjCBwzAIBgYEAI5GAQEwCAYGBACORgEEMBMGBgQAjkYBBjAJBgcEAI5GAQYBMGoGBgQAjkYBBTBgMC4WKGh0dHBzOi8vcWNhLWcxLmRpZ2l0YWxzaWduLnB0L1BEU19wdC5wZGYTAnB0MC4WKGh0dHBzOi8vcWNhLWcxLmRpZ2l0YWxzaWduLnB0L1BEU19lbi5wZGYTAmVuMBUGCCsGAQUFBwsCMAkGBwQAi+xJAQEwFQYIKwYBBQUHCwIwCQYHBACL7EkBAjANBgkqhkiG9w0BAQ0FAAOCAgEAHBjW4N8NKNCiJot414m/L76pB/15LKiGDi1/2V7MHe8u2GcplR1IjESrSEhhwUAW1hwDIK9xJrJ/hdDUMIQcKScSiJCqTCb0Yk39yj/gfOYaN/3fqw8Pjh9k++3Ox7KnvY3R/foFvGJlyiuqaai/JgBmc4qDBHSIDyo5gRw6v70osRPDR5sJs4Xh3FOJn9Y0JZPLF/skYtLrNVysL/4A4bbAxB2DcJ5MpoIegh/fnJ5s2BOVq2Xq8ADpeJoLFYbtlbP7NwsGgew2wKiDW963MlJL/Xa2AqcPVE/UnXFkIBCwZH+covxSEQH2iVcF8cEDHBiYHGERaSmL/uHK/F8soDO9VQwtKNxsiIKAWsQHTYcKfEgVuweyLj7TsCmh6T4pIHqaNDqWvrgEIo0ZwuBmfXVEd+JMSzSgIcJ2bPR2KNoJ14MO4FFYdAAnVlfdhipErsK6R23hlto7b3XKiMRUt9xrvPUjuEJdGI5hPm9CqGK1GxlRoKLewyX7A+OIcPMPu1KfuuUTUn+3hLJJZO5H9k4uVMJ/FOhwzc2VhRpyvNjfmFZksFvseFGvMl5EWIqp3JCo0ItkOBG59ulBwg/99Y0pT6LW9cviTzKIwDtHmQrIgYLa+lCYwWdGhIidXynvLpWiVRZJvYrPIGpzQCRcw9V2i8zT7nksj7QF9v88kto= + + + + + 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 + + + + + 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 + + + + https://ec.europa.eu/tools/lotl/Final_EU_TSL-UKsigned.xml + + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + + + UK + + + application/vnd.etsi.tsl+xml + + + + tScheme Limited + + + + + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/UK + http://uri.etsi.org/TrstSvc/TrustedList/schemerules/EUcommon + + + + + + 2026-09-03T08:17:40Z + + 2027-03-03T09:17:40Z + + + https://ec.europa.eu/tools/lotl/eu-lotl.xml + + +R8bw4IWOih/Wqgmw5D4o7anu80VF0NRb0MlnJILBH1/b2uFMINUpWZT2K2n0yDp180YdCaxNsdiKETScU1Db6Q==LzP6I2aY34XTWoRl4nog3LdhJXPksvtq4XGrpuV7bpqMeqHjF6K7bxe6iYmuU0Esk4zNYne+fDe5iZFZ04jZWQ==NynTUVjbpKfxrG8sXsle8DHhy/oUTjiAO9ph7m14my5PCegFMWyIi1tIZpmksId2xgDQYvhZrn0BD4d/tk+cFdZfMiUIifkyvGaUN5UBlnKkW6N7i74fDxej7lHw85uaiDN5900ZfJos1J4ceD02e1uAidTB5Y4IyuewoRC6ZemIWrXfFpIj+bNhyBtyLp/vCY7OOMFwdl3+IE90X9fP3IlV//3Oiqw/zDZgcyk65AMrwphuyEcl5GjXBUe4easm2Y25UsSUvAr8V/avcSKB8OPHCO0Z0FnuTTJPW6RrHHMNurB4fo4Hycav8AbIK/MUJQ/BGCygWZWckW/cqsaOTaDLfH5p8yhA5Oqckj9nn2QJK0GHbXebTZbgYjaKWe+IW4CujO0waLOkfZaB36TVhN3W/Q3pmVHMNOL6Mgk6grkykhFbGXQug7/tQRScRWb4Xx/Ky6EKOu6buOhUC7AfedG/i7axEiWLZZ0ukrFRWpHPQUjmv6mpQyE+YUc5Yh9qPbVFVN4ZYBSf2+Q5CqqnP35FwXmrTO/0ORsYUSHs7Q8NA6AuZ+iRNThucebIGHu4Wd/+1DJE2FodEyaqO8qH9sTJzjVFSWanj10LI+DFsTsuUm454h2HfpRfKeDRxMXfHLFiZbUkyrm9aFJjEfwQX6WZNSAamWArVZhSz/cZkvI=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2026-09-03T08:20:30ZMChItQCvaWcTKbZ1lIIXL2BVbmm0YgKgZVrgIx0FFUhNIdTlv6RylET5voFVvbYBiGh3nUr2rsAQouSJzYkTaQ==MHswY6RhMF8xCzAJBgNVBAYTAlBUMSowKAYDVQQKDCFEaWdpdGFsU2lnbiBDZXJ0aWZpY2Fkb3JhIERpZ2l0YWwxJDAiBgNVBAMMG0RJR0lUQUxTSUdOIFFVQUxJRklFRCBDQSBHMQIUc8IcSUtVEKAMMvHm9QWU05kXsPU=text/xml \ No newline at end of file From 41b236df21cb7c64967c6d9c7d40b536a0922565 Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Fri, 11 Sep 2026 04:44:37 +0200 Subject: [PATCH 6/8] feat(seal): verify national trusted lists against the LOTL --- crates/dpp-seal/src/trustlist/chain_tests.rs | 268 +++++++++++++++++++ crates/dpp-seal/src/trustlist/fetch.rs | 38 ++- crates/dpp-seal/src/trustlist/mod.rs | 58 ++-- crates/dpp-seal/src/trustlist/model.rs | 47 +++- crates/dpp-seal/src/trustlist/parse.rs | 57 +++- crates/dpp-seal/src/trustlist/tests.rs | 67 ++++- crates/dpp-seal/src/trustlist/verify.rs | 178 ++++++++++++ 7 files changed, 661 insertions(+), 52 deletions(-) create mode 100644 crates/dpp-seal/src/trustlist/chain_tests.rs diff --git a/crates/dpp-seal/src/trustlist/chain_tests.rs b/crates/dpp-seal/src/trustlist/chain_tests.rs new file mode 100644 index 00000000..ec330c50 --- /dev/null +++ b/crates/dpp-seal/src/trustlist/chain_tests.rs @@ -0,0 +1,268 @@ +//! The whole chain: Official Journal → list of lists → a national list. + +use super::verify::{TrustedListRejected, verify_lotl, verify_trusted_list}; +use dpp_domain::trusted_list::TrustServiceType; + +const EU_LOTL: &str = include_str!("../../tests/fixtures/eu-lotl.xml"); +const FI_LIST: &str = include_str!("../../tests/fixtures/fi-trusted-list.xml"); + +/// The pointer the verified LOTL carries for Finland. +fn finnish_pointer() -> super::model::TrustedListPointer { + let lotl = verify_lotl(EU_LOTL).expect("the LOTL verifies"); + lotl.pointers() + .iter() + .find(|p| p.territory.as_deref() == Some("FI")) + .expect("the LOTL points at Finland") + .clone() +} + +/// The chain closes: a national list verifies against a verified LOTL. +/// +/// The claim the whole module exists for. Nothing in this test trusts a document +/// because it was fetched — the Official Journal vouches for the list of lists, +/// and the list of lists vouches for Finland. +/// +/// Note what is *not* pinned anywhere: Finland's certificates. They arrive in a +/// document that was itself verified, which is the point of a list of lists. +#[test] +fn a_national_list_verifies_through_the_verified_lotl() { + let pointer = finnish_pointer(); + assert!( + !pointer.certificates.is_empty(), + "the LOTL names Finland's signing certificates" + ); + + let verified = verify_trusted_list(FI_LIST, &pointer).expect("Finland's list verifies"); + + assert_eq!(verified.territory(), Some("FI")); + assert!(!verified.providers().is_empty()); + assert!( + verified + .providers_offering(TrustServiceType::QUALIFIED_CERTIFICATE_CA) + .count() + > 0, + "and the Art. 39a-style lookup now runs over verified content" + ); +} + +/// A Member State names several certificates, and any of them may be the signer. +/// +/// Not an edge case: a scheme operator rotating its certificate publishes the +/// old and the new together so relying parties do not break at the cutover. A +/// verifier that accepted only the first listed would fail every Member State on +/// the day it rotated — intermittently, and only for some countries. +#[test] +fn any_of_the_named_certificates_may_be_the_signer() { + let pointer = finnish_pointer(); + assert!( + pointer.certificates.len() > 1, + "Finland names several, which is why position must not matter" + ); + + // Verification succeeds without the signer being first. + let mut reordered = pointer.clone(); + reordered.certificates.rotate_left(1); + assert!(verify_trusted_list(FI_LIST, &reordered).is_ok()); + + let mut reversed = pointer.clone(); + reversed.certificates.reverse(); + assert!(verify_trusted_list(FI_LIST, &reversed).is_ok()); +} + +/// A list signed by a key the LOTL does not name for it is refused. +/// +/// The substitution this link exists to stop: a genuine, correctly signed +/// trusted list from *somewhere else* served in place of Finland's. Its +/// signature is perfect; what is wrong is who signed it. +/// +/// Reported as `NotNamedByLotl` rather than `SignatureInvalid`, because the two +/// send an operator in opposite directions — one to the Member State, the other +/// to hunt a tampered document that does not exist. +#[test] +fn a_list_signed_by_an_unnamed_certificate_is_refused() { + let mut pointer = finnish_pointer(); + // Keep the shape, drop the real signer: certificates from another territory. + let lotl = verify_lotl(EU_LOTL).expect("verifies"); + let other = lotl + .pointers() + .iter() + .find(|p| p.territory.as_deref() == Some("BE") && !p.certificates.is_empty()) + .expect("the LOTL points at Belgium too"); + pointer.certificates = other.certificates.clone(); + + match verify_trusted_list(FI_LIST, &pointer) { + Err(TrustedListRejected::NotNamedByLotl { + offered, + authorised, + }) => { + assert!(!offered.is_empty()); + assert_eq!(authorised, other.certificates.len()); + } + other => panic!("Belgium does not sign Finland's list, got {other:?}"), + } +} + +/// A tampered national list is refused even though its signer is named. +/// +/// The other half of the pair above. Here the certificate is right and the bytes +/// are not, so the answer must be `SignatureInvalid` — someone touched the +/// document. +/// +/// The tamper flips one service status at equal length, which is the change that +/// would actually pay: making a withdrawn trust service read as granted. +#[test] +fn a_tampered_national_list_is_refused_as_a_bad_signature() { + let from = "Svcstatus/withdrawn"; + let to = "Svcstatus/granted__"; + assert_eq!(from.len(), to.len(), "the tamper must not change length"); + + let at = FI_LIST + .find(from) + .expect("the fixture carries a withdrawal"); + let mut tampered = String::with_capacity(FI_LIST.len()); + tampered.push_str(&FI_LIST[..at]); + tampered.push_str(to); + tampered.push_str(&FI_LIST[at + from.len()..]); + + match verify_trusted_list(&tampered, &finnish_pointer()) { + Err(TrustedListRejected::SignatureInvalid(_)) => {} + other => panic!("a flipped service status must be caught, got {other:?}"), + } +} + +/// A pointer naming no certificates verifies nothing. +/// +/// Distinct from a mismatch: there is nothing to check against, and saying so +/// separately keeps "the LOTL vouches for nobody here" from reading as "the +/// signature was wrong". +#[test] +fn a_pointer_with_no_certificates_is_refused_distinctly() { + let mut pointer = finnish_pointer(); + pointer.certificates.clear(); + + assert_eq!( + verify_trusted_list(FI_LIST, &pointer), + Err(TrustedListRejected::NoAuthorisedCertificates) + ); +} + +/// Having a territory does not make a pointer a national list. +/// +/// This test was written asserting the opposite — that non-national pointers are +/// the ones with no `SchemeTerritory` — and failed, which is how the two cases +/// below were found. **Every** pointer in the published LOTL carries a territory, +/// so presence of one distinguishes nothing, and the filter that used it would +/// have fetched two kinds of document that are not trusted lists. +#[test] +fn a_territory_does_not_make_a_pointer_a_national_list() { + let lotl = verify_lotl(EU_LOTL).expect("verifies"); + let pointers = lotl.pointers(); + + assert!( + pointers.iter().all(|p| p.territory.is_some()), + "every pointer names a territory, so the field separates nothing" + ); + + // The LOTL points at itself, to declare its own signing certificates. + let self_pointer = pointers + .iter() + .find(|p| { + p.tsl_type.as_deref() + == Some("http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUlistofthelists") + }) + .expect("the LOTL carries a pointer to itself"); + assert_eq!(self_pointer.territory.as_deref(), Some("EU")); + assert_eq!(self_pointer.location, super::fetch::EU_LOTL_URL); + + // And several Member States publish a PDF beside the XML, same territory. + let pdfs: Vec<_> = pointers + .iter() + .filter(|p| p.mime_type.as_deref() == Some("application/pdf")) + .collect(); + assert!( + !pdfs.is_empty(), + "some Member States publish a human-readable PDF as a second pointer" + ); + assert!( + pdfs.iter() + .all(|pdf| pointers.iter().any(|p| p.territory == pdf.territory + && p.mime_type.as_deref() == Some("application/vnd.etsi.tsl+xml"))), + "each PDF sits beside the XML for the same territory, not instead of it" + ); + + let national = super::fetch::national_pointers(pointers); + assert!(national.len() >= 20, "most pointers are national lists"); + assert!( + !national + .iter() + .any(|p| p.location == super::fetch::EU_LOTL_URL), + "and the filter keeps the list of lists out of its own refresh" + ); + assert!( + !national + .iter() + .any(|p| p.mime_type.as_deref() == Some("application/pdf")), + "and keeps the PDFs out too" + ); +} + +/// Every national pointer names at least one signing certificate. +/// +/// The property the second link of the chain rests on. A pointer naming none +/// would be refused by [`verify_trusted_list`] with `NoAuthorisedCertificates`, +/// so a Member State that stopped publishing them would drop out of the refresh +/// entirely — worth knowing as a fact about the published document rather than +/// discovering as an outage. +#[test] +fn every_national_pointer_carries_certificates_to_verify_against() { + let lotl = verify_lotl(EU_LOTL).expect("verifies"); + let national = super::fetch::national_pointers(lotl.pointers()); + assert!( + national.len() >= 20, + "there are lists to check, so an empty result would not prove this" + ); + + let bare: Vec<_> = national + .iter() + .filter(|p| p.certificates.is_empty()) + .map(|p| p.territory.as_deref().unwrap_or(&p.location)) + .collect(); + assert!( + bare.is_empty(), + "these name no signing certificate: {bare:?}" + ); +} + +/// Each signature names exactly one certificate, so "the signer" is unambiguous. +/// +/// The assumption underneath both links of the chain, pinned because it is +/// invisible in the code that relies on it. Two separate things read the +/// document: this module takes the **first** `X509Certificate` under the +/// signature and compares it against what the LOTL authorises, while `xml-sec` +/// resolves a key of its own to check the signature with. They agree only while +/// there is one certificate to choose. +/// +/// XMLDSig permits a `KeyInfo` to carry a whole chain, and the order within it +/// is not fixed. If a publisher ever ships one, the two could diverge — the +/// certificate we vouched for would not be the certificate that verified — and +/// the failure would be silent. This test goes red first instead. +#[test] +fn each_signature_names_exactly_one_certificate() { + for (what, xml) in [("the LOTL", EU_LOTL), ("Finland's list", FI_LIST)] { + let doc = roxmltree::Document::parse(xml).expect("parses"); + let signature = doc + .descendants() + .find(|n| n.is_element() && n.tag_name().name() == "Signature") + .expect("is signed"); + let certificates = signature + .descendants() + .filter(|n| n.is_element() && n.tag_name().name() == "X509Certificate") + .count(); + + assert_eq!( + certificates, 1, + "{what} names {certificates} certificates in its signature; picking the first is \ + no longer unambiguous — see this test's note" + ); + } +} diff --git a/crates/dpp-seal/src/trustlist/fetch.rs b/crates/dpp-seal/src/trustlist/fetch.rs index 5cfea366..3afa677b 100644 --- a/crates/dpp-seal/src/trustlist/fetch.rs +++ b/crates/dpp-seal/src/trustlist/fetch.rs @@ -52,15 +52,41 @@ pub async fn fetch_lotl_pointers() -> Result, SealError> parse_lotl(&xml) } -/// The pointers that name a scheme territory — the national trusted lists. +/// `TSLType` of a Member State's trusted list. +const TSL_TYPE_NATIONAL: &str = "http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric"; + +/// The MIME type of a machine-processable trusted list. +const TSL_MIME_XML: &str = "application/vnd.etsi.tsl+xml"; + +/// The pointers that are national trusted lists in machine-processable form. +/// +/// # Two things this filters out, both of which bite +/// +/// **The self-pointer.** The LOTL points at *itself* with `TSLType` +/// `…/EUlistofthelists`, which is how it declares its own signing certificates. +/// It has a scheme territory (`EU`) and a location like any other pointer, so a +/// filter on "has a territory" keeps it and a refresh then fetches the list of +/// lists again as though it were a country's list. +/// +/// **The PDF variants.** Several Member States publish a human-readable PDF +/// beside the XML as a second pointer with the same territory — Bulgaria, +/// Czechia, Estonia and Portugal among them. Fetching one yields a parse failure +/// that reads like a broken trusted list rather than the wrong document. +/// +/// Both were found by a test that asserted the opposite and failed. Every +/// pointer in the published LOTL carries a territory, so presence of one +/// distinguishes nothing. /// -/// The rest are the list of lists' own historical pivot documents, which record -/// how it changed over time and are not trusted lists. They parse without error -/// and yield no providers, so fetching them wastes a request and produces an -/// empty result that reads like a country with no trust services. +/// A pointer that declares no MIME type is kept: the field is optional, and +/// dropping a list because its publisher omitted an annotation would lose a +/// country for a reason that has nothing to do with the document. #[must_use] pub fn national_pointers(pointers: &[TrustedListPointer]) -> Vec<&TrustedListPointer> { - pointers.iter().filter(|p| p.territory.is_some()).collect() + pointers + .iter() + .filter(|p| p.tsl_type.as_deref() == Some(TSL_TYPE_NATIONAL)) + .filter(|p| p.mime_type.as_deref().is_none_or(|m| m == TSL_MIME_XML)) + .collect() } /// Fetch and parse one national trusted list. diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index a581ea69..76f0be1a 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -7,34 +7,45 @@ //! a vendor. The vocabulary those lists are written in lives in //! [`dpp_domain::trusted_list`]; this module fetches and parses the documents. //! -//! # What is verified, and what is not +//! # The chain, and where it is anchored //! //! A trusted list is an **XAdES-signed** XML document, and that signature is -//! what makes it evidence rather than a file from a web server. The two kinds of -//! document here are at different stages: +//! what makes it evidence rather than a file from a web server. Two links carry +//! the whole thing, and each is verified against the one above it: //! -//! - **The list of lists is verified.** [`verify_lotl`] checks that the -//! certificate in its `ds:KeyInfo` is one the Official Journal authorises -//! ([`EU_LOTL_ANCHOR`]) and that the XML signature verifies with it. Success -//! yields a [`VerifiedLotl`], which has no public constructor — holding one is -//! evidence the check ran. -//! - **National lists are not.** [`parse_trusted_list`] yields an -//! [`UnverifiedTrustedList`], and the name is the warning. Their signing -//! certificates are named by the LOTL per territory, so verifying them is the -//! next step and reuses the same machinery. +//! 1. **The Official Journal vouches for the list of lists.** [`verify_lotl`] +//! checks that the certificate in the document's `ds:KeyInfo` is one the +//! Commission's notice authorises ([`EU_LOTL_ANCHOR`], compiled in) and that +//! the XML signature verifies with it. Success yields a [`VerifiedLotl`]. +//! 2. **The list of lists vouches for each national list.** Every pointer names +//! the certificates authorised to sign the list it points at, so +//! [`verify_trusted_list`] takes a pointer *out of a verified LOTL* and +//! checks a Member State's document against it. Success yields a +//! [`VerifiedTrustedList`]. //! -//! So a national list is still *what a server answered*, not *what a Member -//! State published*. That is sound for reading — answering "which service types -//! is this provider listed under, and with what status?", which is the only -//! automated starting point for the Art. 39a check -//! ([`TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT`](dpp_domain::trusted_list::TrustServiceType::REMOTE_QSEAL_CD_MANAGEMENT)). -//! It is **not** sound for a compliance verdict, and in particular must not -//! produce [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation), -//! which asserts the legs of Art. 32(1) were checked. +//! Neither type has a public constructor: holding one is evidence the check ran. +//! Note what is consequently **not** pinned anywhere — no Member State's +//! certificates, only the Commission's. Adding a country needs no code change, +//! and that is most of the point of having a list of lists. +//! +//! [`parse_trusted_list`] remains, and yields an [`UnverifiedTrustedList`] whose +//! name is the warning: *what a server answered*, not *what a Member State +//! published*. Use it only where no verified LOTL is at hand. Neither form may +//! produce [`SealChecks::QualifiedValidation`](dpp_domain::seal::SealChecks::QualifiedValidation) +//! on its own — that asserts the legs of Art. 32(1) were checked, and a list +//! says who is qualified, not that a particular seal validates. //! //! Same discipline [`crate::cades`] applies to a seal's own bytes: read, report, //! and never imply a check that did not happen. //! +//! ## Not every pointer is a trusted list +//! +//! The LOTL points at **itself** — that is how it publishes its own signing +//! certificates — and several Member States publish a human-readable PDF beside +//! their XML as a second pointer. All of them carry a `SchemeTerritory`, so that +//! field separates nothing. [`national_pointers`] is the filter, and it reads +//! `TSLType` and `MimeType` instead. +//! //! ## The canonicalisation problem, and the vendored fix //! //! XML Signature verifies a digest over the **canonicalised** subtree, not over @@ -66,6 +77,8 @@ mod anchor; #[cfg(test)] mod anchor_tests; +#[cfg(test)] +mod chain_tests; mod fetch; mod model; mod parse; @@ -81,4 +94,7 @@ pub use fetch::{ }; pub use model::{ListedProvider, ListedService, TrustedListPointer, UnverifiedTrustedList}; pub use parse::{parse_lotl, parse_trusted_list}; -pub use verify::{LotlRejected, VerifiedLotl, verify_lotl, verify_lotl_with}; +pub use verify::{ + LotlRejected, TrustedListRejected, VerifiedLotl, VerifiedTrustedList, verify_lotl, + verify_lotl_with, verify_trusted_list, +}; diff --git a/crates/dpp-seal/src/trustlist/model.rs b/crates/dpp-seal/src/trustlist/model.rs index 589fd148..74b0cec0 100644 --- a/crates/dpp-seal/src/trustlist/model.rs +++ b/crates/dpp-seal/src/trustlist/model.rs @@ -120,9 +120,48 @@ pub struct TrustedListPointer { pub location: String, /// The `SchemeTerritory` this pointer is for, where the LOTL gave one. /// - /// `None` for the pointers that are not national lists — the LOTL also - /// points at its own historical pivot documents, which carry no territory - /// and are not trusted lists. Filtering on this is how a caller tells them - /// apart; see [`super::parse::parse_lotl`]. + /// In practice every pointer in the published LOTL carries one, including + /// the self-pointer, whose territory is `EU`. **Presence is therefore not a + /// way to tell a national list from anything else** — use [`Self::tsl_type`] + /// and [`Self::mime_type`], which is what [`super::national_pointers`] does. pub territory: Option, + /// The `TSLType` URI — what kind of list this points at. + /// + /// Two values appear: `…/TSLType/EUgeneric` for a Member State's list, and + /// `…/TSLType/EUlistofthelists` for the LOTL's pointer **to itself**, which + /// is how it declares its own signing certificates. + /// + /// That self-pointer is why this field exists. It has a territory (`EU`) and + /// a location like any other, so anything that treats "has a territory" as + /// "is a national list" will re-fetch the list of lists as though it were a + /// country's. + pub tsl_type: Option, + /// The declared MIME type of the document at [`Self::location`]. + /// + /// Several Member States publish a **human-readable PDF alongside the XML**, + /// as two separate pointers with the same territory — Bulgaria, Czechia, + /// Estonia and Portugal among them. The PDF is not machine-processable and + /// fetching it yields a parse failure that looks like a broken list rather + /// than the wrong document. + /// + /// `application/vnd.etsi.tsl+xml` is the one to want. + pub mime_type: Option, + /// The certificates authorised to sign the list this points at, base64 DER + /// as published. + /// + /// This is the second link of the trust chain. The list of lists is anchored + /// on the Official Journal; each national list is anchored on **this** — + /// the set its pointer names, inside a LOTL that has itself been verified. + /// So no national list needs pinning of its own, which is most of the point + /// of having a list of lists. + /// + /// Several per pointer is normal rather than exceptional: a Member State + /// rotating its scheme operator certificate publishes the old and the new + /// together so relying parties do not break at the cutover. Finland names + /// five. + /// + /// **Only meaningful once the LOTL carrying it has been verified.** Taken + /// from an unverified document these are whatever the document said, and + /// trusting them would move the problem rather than solve it. + pub certificates: Vec, } diff --git a/crates/dpp-seal/src/trustlist/parse.rs b/crates/dpp-seal/src/trustlist/parse.rs index 8b972eec..0b58b007 100644 --- a/crates/dpp-seal/src/trustlist/parse.rs +++ b/crates/dpp-seal/src/trustlist/parse.rs @@ -193,12 +193,20 @@ fn collect_certificates(node: Node<'_, '_>) -> Vec { /// /// # The LOTL points at more than national lists /// -/// It also points at its own historical *pivot* documents, which record how the -/// list of lists itself changed over time. Those carry no `SchemeTerritory`, -/// which is how they are told apart — see -/// [`TrustedListPointer::territory`](super::model::TrustedListPointer::territory). -/// Fetching one as though it were a national list would parse and yield nothing, -/// which is the quiet kind of wrong. +/// Every pointer is returned, including the LOTL's pointer **to itself** — the +/// one carrying its own signing certificates, with `TSLType` `…/EUlistofthelists` +/// — and the human-readable PDF that several Member States publish beside their +/// XML. Both look exactly like a national list if the only question asked is +/// whether a `SchemeTerritory` is present, and both are the quiet kind of wrong +/// to fetch: one re-fetches the list of lists, the other fails to parse. +/// +/// Filtering is [`national_pointers`](super::national_pointers)'s job, and the +/// fields it needs are [`tsl_type`](super::model::TrustedListPointer::tsl_type) +/// and [`mime_type`](super::model::TrustedListPointer::mime_type). +/// +/// The historical *pivot* documents — which record how the list of lists itself +/// changed over time — are **not** pointers at all. They are listed in +/// `SchemeInformationURI`, and this function does not return them. pub fn parse_lotl(xml: &str) -> Result, SealError> { let doc = Document::parse(xml).map_err(|e| malformed(format!("not XML: {e}")))?; let root = doc.root_element(); @@ -214,23 +222,46 @@ pub fn parse_lotl(xml: &str) -> Result, SealError> { .filter_map(|p| { let location = child_text(p, "TSLLocation")?; Some(TrustedListPointer { - territory: pointer_territory(p), + territory: pointer_info(p, "SchemeTerritory").map(|t| t.to_uppercase()), + tsl_type: pointer_info(p, "TSLType"), + mime_type: pointer_info(p, "MimeType"), + certificates: pointer_certificates(p), location, }) }) .collect()) } -/// The scheme territory an `OtherTSLPointer` declares, if any. +/// Every certificate an `OtherTSLPointer` names as authorised to sign the list +/// it points at. +/// +/// Searched by descendant rather than addressed by path: the certificates sit +/// under `ServiceDigitalIdentities` → `ServiceDigitalIdentity` → `DigitalId`, +/// and a `DigitalId` may carry other identifier forms — a subject name, a key +/// hash — beside or instead of an X.509 certificate. Walking to the certificates +/// directly takes the ones that exist and ignores the rest, rather than +/// depending on every publisher nesting them identically. +fn pointer_certificates(pointer: Node<'_, '_>) -> Vec { + pointer + .descendants() + .filter(|n| n.is_element() && n.tag_name().name() == "X509Certificate") + .filter_map(|n| n.text()) + .map(|t| t.split_whitespace().collect::()) + .filter(|s| !s.is_empty()) + .collect() +} + +/// One value out of an `OtherTSLPointer`'s `AdditionalInformation`. /// -/// It is not a child element but one of a bag of typed `OtherInformation` -/// entries, so it has to be searched for rather than addressed. -fn pointer_territory(pointer: Node<'_, '_>) -> Option { +/// These are not child elements but a bag of typed `OtherInformation` entries — +/// scheme territory, MIME type, scheme operator name — so each has to be +/// searched for rather than addressed by path. +fn pointer_info(pointer: Node<'_, '_>, name: &str) -> Option { child(pointer, "AdditionalInformation")? .descendants() - .find(|n| n.is_element() && n.tag_name().name() == "SchemeTerritory") + .find(|n| n.is_element() && n.tag_name().name() == name) .and_then(|n| n.text()) .map(str::trim) .filter(|s| !s.is_empty()) - .map(str::to_uppercase) + .map(ToOwned::to_owned) } diff --git a/crates/dpp-seal/src/trustlist/tests.rs b/crates/dpp-seal/src/trustlist/tests.rs index bae466b9..c988e42f 100644 --- a/crates/dpp-seal/src/trustlist/tests.rs +++ b/crates/dpp-seal/src/trustlist/tests.rs @@ -178,33 +178,84 @@ fn a_status_without_a_start_time_is_dropped() { ); } -/// The list of lists yields its pointers, and the pivots are distinguishable. +/// The list of lists yields every pointer; only one of these three is a list. +/// +/// The three shapes the published document actually contains. Note that all of +/// them name a territory — including the LOTL's pointer to itself — which is why +/// the filter reads `TSLType` and `MimeType` instead. #[test] -fn lotl_pointers_carry_their_territory_where_there_is_one() { +fn only_the_machine_readable_national_pointer_survives_the_filter() { let xml = r#" + + https://example.test/eu-lotl.xml + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUlistofthelists + EU + application/vnd.etsi.tsl+xml + + https://example.test/TSL-FI.xml - - FI - + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + FI + application/vnd.etsi.tsl+xml + - https://example.test/eu-lotl-pivot-300.xml + https://example.test/TSL-FI.pdf + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + FI + application/pdf + "#; let pointers = parse_lotl(xml).expect("parses"); - assert_eq!(pointers.len(), 2, "both pointers are returned"); + assert_eq!(pointers.len(), 3, "every pointer is returned"); + assert!( + pointers.iter().all(|p| p.territory.is_some()), + "including the self-pointer, whose territory is EU" + ); let national = national_pointers(&pointers); - assert_eq!(national.len(), 1, "only one names a territory"); + assert_eq!( + national.len(), + 1, + "the list of lists and the PDF are not lists" + ); assert_eq!(national[0].territory.as_deref(), Some("FI")); assert_eq!(national[0].location, "https://example.test/TSL-FI.xml"); } +/// A pointer that declares no MIME type is kept. +/// +/// The field is optional in TS 119 612. Dropping a Member State because its +/// publisher omitted an annotation would lose a country for a reason that has +/// nothing to do with the document behind the pointer. +#[test] +fn a_pointer_without_a_mime_type_is_still_a_national_list() { + let xml = r#" + + + + https://example.test/TSL-SE.xml + + http://uri.etsi.org/TrstSvc/TrustedList/TSLType/EUgeneric + SE + + + +"#; + + let pointers = parse_lotl(xml).expect("parses"); + assert_eq!(national_pointers(&pointers).len(), 1); +} + /// Looking up a service type finds only that type. /// /// The Art. 39a question in miniature: the qualified remote-seal-device service diff --git a/crates/dpp-seal/src/trustlist/verify.rs b/crates/dpp-seal/src/trustlist/verify.rs index 5c80ecad..aab6512e 100644 --- a/crates/dpp-seal/src/trustlist/verify.rs +++ b/crates/dpp-seal/src/trustlist/verify.rs @@ -183,6 +183,184 @@ pub fn verify_lotl_with(xml: &str, anchor: &LotlAnchor) -> Result) -> std::fmt::Result { + match self { + Self::Malformed(why) => write!(f, "not a readable trusted list: {why}"), + Self::NotSigned => f.write_str("the document carries no signature"), + Self::NoCertificate => f.write_str("the signature carries no certificate"), + Self::NoAuthorisedCertificates => { + f.write_str("the list of trusted lists names no certificate for this list") + } + Self::NotNamedByLotl { + offered, + authorised, + } => write!( + f, + "signed by {offered}, which is not among the {authorised} certificate(s) the \ + list of trusted lists names for it — the scheme operator may be mid-rotation, \ + or this document is not theirs" + ), + Self::SignatureInvalid(why) => write!(f, "the signature does not verify: {why}"), + } + } +} + +impl std::error::Error for TrustedListRejected {} + +/// A national trusted list whose signature has been verified against the +/// certificates a **verified** list of trusted lists names for it. +/// +/// No public constructor, for the same reason [`VerifiedLotl`] has none. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct VerifiedTrustedList { + content: super::model::UnverifiedTrustedList, + signed_by: String, +} + +impl VerifiedTrustedList { + /// The `SchemeTerritory`, where the list gives one. + #[must_use] + pub fn territory(&self) -> Option<&str> { + self.content.territory.as_deref() + } + + /// The providers the list carries. + #[must_use] + pub fn providers(&self) -> &[super::model::ListedProvider] { + &self.content.providers + } + + /// Providers listed for a service type, with those services. + /// + /// The lookup the Art. 39a question needs, now over content that has been + /// verified rather than merely fetched. + pub fn providers_offering<'a>( + &'a self, + service_type: &'a str, + ) -> impl Iterator< + Item = ( + &'a super::model::ListedProvider, + Vec<&'a super::model::ListedService>, + ), + > + 'a { + self.content.providers_offering(service_type) + } + + /// Base64 SHA-256 of the certificate that signed it. + #[must_use] + pub fn signed_by(&self) -> &str { + &self.signed_by + } +} + +/// Verify a national trusted list against the certificates its pointer names. +/// +/// `pointer` must come from a [`VerifiedLotl`]. That is the whole chain: the +/// Official Journal anchors the list of lists, and the list of lists anchors +/// every national list. Taking a pointer from an unverified document would move +/// the trust problem rather than solve it, which is why +/// [`TrustedListPointer::certificates`] says so too. +/// +/// # Errors +/// +/// [`TrustedListRejected`]. Note the deliberate split between +/// [`TrustedListRejected::NotNamedByLotl`] and +/// [`TrustedListRejected::SignatureInvalid`]: the first is a document signed by +/// the wrong key, the second a document altered after signing, and only the +/// second means someone touched the bytes. +pub fn verify_trusted_list( + xml: &str, + pointer: &TrustedListPointer, +) -> Result { + if pointer.certificates.is_empty() { + return Err(TrustedListRejected::NoAuthorisedCertificates); + } + + let certificate = signing_certificate(xml).map_err(|e| match e { + LotlRejected::Malformed(why) => TrustedListRejected::Malformed(why), + LotlRejected::NotSigned => TrustedListRejected::NotSigned, + _ => TrustedListRejected::NoCertificate, + })?; + + // Compared as the published base64 rather than by digest: the LOTL carries + // the certificates themselves, so there is nothing to hash against and a + // digest step would only add a place to disagree about encoding. + if !pointer.certificates.iter().any(|c| c == &certificate) { + let der = base64::engine::general_purpose::STANDARD + .decode(&certificate) + .unwrap_or_default(); + return Err(TrustedListRejected::NotNamedByLotl { + offered: base64::engine::general_purpose::STANDARD + .encode(::digest(&der)), + authorised: pointer.certificates.len(), + }); + } + + let resolver = DefaultKeyResolver::default(); + let outcome = VerifyContext::new() + .key_resolver(&resolver) + .verify(xml) + .map_err(|e| TrustedListRejected::SignatureInvalid(e.to_string()))?; + + if !matches!(outcome.status, DsigStatus::Valid) { + return Err(TrustedListRejected::SignatureInvalid(format!( + "{:?}", + outcome.status + ))); + } + + let content = super::parse::parse_trusted_list(xml) + .map_err(|e| TrustedListRejected::Malformed(e.to_string()))?; + + let der = base64::engine::general_purpose::STANDARD + .decode(&certificate) + .unwrap_or_default(); + Ok(VerifiedTrustedList { + content, + signed_by: base64::engine::general_purpose::STANDARD + .encode(::digest(&der)), + }) +} + /// The base64 certificate from the document's signature. /// /// Read with the same local-name matching the rest of this module uses: the From ad247db18ac27097f70e747b5cbccfc630521fdc Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Tue, 15 Sep 2026 06:36:34 +0200 Subject: [PATCH 7/8] chore(deps): allow the pinned xml-sec fork as a source --- CHANGELOG.md | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ deny.toml | 24 +++++++++++++++++++++++- 2 files changed, 75 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index bcf40b1a..27ce23c7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -75,6 +75,58 @@ under the pre-1.0 conventions in [VERSIONING.md](docs/governance/VERSIONING.md): The create/update path and `POST /dpp/{dppId}/lint` now compute the result through one function. They did not before, so a check added to one and not the other would have made the route disagree with the record it re-checks. +- **The EU Trusted Lists can now be read and verified.** New + `dpp_seal::trustlist`: `verify_lotl` for the List of Trusted Lists, + `verify_trusted_list` for a Member State's, plus the parsers, the fetcher and + the typed rejections. Nothing calls it yet — this is the reader, not a + policy. + + **The trust anchor is an Official Journal notice, not a certificate + authority.** The LOTL's signing certificates chain to no commercial root; they + are published in the OJ C series, which the LOTL itself names through + `SchemeInformationURI`. So there is nothing to walk up to, and the anchor is + six SHA-256 digests taken from notice `52026XC01944`, compiled in with the + location, CELEX and pin date beside them. + + **Compiled in, never configuration.** An operator who can repoint the anchor + can make any list verify. + + **Six digests are the entire pinned surface.** No Member State's certificates + live in the repository — they arrive inside a document that has already been + verified, so a country joining or rotating its certificate needs no code change + and no release. That is the whole payoff of a list of lists. + + `authorises` is a **precondition, not a verdict**: anyone can copy the genuine + certificate into a forgery and pass it. Only the signature separates them. + Conversely a valid signature alone proves nothing about authority — Finland's + list is genuine and correctly signed by Finland, which does not sign the LOTL, + and it verifies cleanly with the anchor check disabled. That pair is why both + halves exist. + + 🚨 **This creates a recurring operational obligation.** The pin must be + refreshed when the Commission republishes the notice, and the current signer + expires **2027-11-17** — a calendar date, not a discovery. A stale pin fails + closed and looks like an outage, so the reader also has the early signal: the + LOTL's first `SchemeInformationURI` entry is the current notice. + + `TrustedListRejected` is a separate enum from `LotlRejected` deliberately: a + rejected LOTL usually means our pin is stale, a rejected national list never + does, and the two send an operator in different directions. + +- **`xml-sec` is pinned to an organisation fork, temporarily.** Italy (2.86 MB) + and France (2.55 MB) exceed a compile-time node-set ceiling in the published + crate and cannot be verified at any configuration — the constant is + `pub(crate)` and the policy knob that appears to raise it is validated against + the same number. They miss it by four and five nodes, and trusted lists only + grow. + + The fork changes that one constant and nothing else. It is a pinned git rev + rather than a vendored copy because the crate is ~66k LOC: vendoring would make + every upstream sync a 66k-line diff and bury the one line that is ours. + `deny.toml` carries the matching source allowance and the same exit condition. + + Filed upstream as `structured-world/xml-sec#158`. **When that resolves, the + `[patch.crates-io]` stanza and the `deny.toml` entry go together.** - **The passport response now serves `serialNumber`, `lifeStatus` and `responsibleOperator`.** All three are modelled on the core aggregate and were diff --git a/deny.toml b/deny.toml index 257302d3..1696d041 100644 --- a/deny.toml +++ b/deny.toml @@ -277,7 +277,29 @@ unknown-git = "deny" # if not specified. If it is specified but empty, no registries are allowed. allow-registry = ["https://github.com/rust-lang/crates.io-index"] # List of URLs for allowed Git repositories -allow-git = [] +# +# One entry, and it is meant to be temporary. `xml-sec` verifies the XMLDSig +# signature on the EU List of Trusted Lists and on each national list. Two of +# those — Italy at 2.86 MB and France at 2.55 MB — exceed a compile-time node-set +# ceiling in the published crate and cannot be verified at any configuration: +# `NODE_SET_ENTRY_CEILING` is `pub(crate)`, and the policy knob that looks like it +# raises it is validated against the same constant. They miss by four and five +# nodes, and trusted lists only grow. +# +# The fork changes that one constant and nothing else, which is why it is a +# pinned git rev rather than a vendored copy: the crate is ~66k LOC, so vendoring +# would turn every upstream sync into a 66k-line diff and hide the one line that +# is ours. Pinned by rev, not branch, so the reviewed commit is the one that +# builds. +# +# Filed upstream as structured-world/xml-sec#158. **Exit condition: when that +# resolves, drop the `[patch.crates-io]` stanza in the workspace `Cargo.toml` and +# this entry together.** The fork's own commit message says the same thing. +# +# The rule above still stands for everything else — a git dependency is how +# unreviewed code enters a build, and this one is allowed because the review is +# a single constant, not because forks are fine. +allow-git = ["https://github.com/odal-node/xml-sec"] [sources.allow-org] # github.com organizations to allow git sources for From 44122c0cf648d836224f73dacbbc1beeee98caa7 Mon Sep 17 00:00:00 2001 From: LKSNDRTMLKV Date: Tue, 15 Sep 2026 10:03:30 +0200 Subject: [PATCH 8/8] feat(seal): warn when the pinned anchor has been superseded --- CHANGELOG.md | 30 +++++ crates/dpp-seal/src/trustlist/mod.rs | 4 +- crates/dpp-seal/src/trustlist/verify.rs | 106 ++++++++++++++++++ crates/dpp-seal/src/trustlist/verify_tests.rs | 100 ++++++++++++++++- 4 files changed, 237 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 27ce23c7..1eb078fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -51,6 +51,36 @@ under the pre-1.0 conventions in [VERSIONING.md](docs/governance/VERSIONING.md): ### Added +- **A verified list of trusted lists now says whether the pin it verified + against is still the notice in force.** New `AnchorFreshness` on + `VerifiedLotl`: `Current`, `Superseded { lotl_names }`, or `Unknown`. + + The trust anchor is pinned from an Official Journal notice rather than chained + to a certificate authority, and the Commission republishes that notice. A pin + nobody refreshes eventually meets a LOTL signed by a certificate it does not + name and fails closed as `NotAnchored` — on a date nobody has in a calendar, + looking like an outage rather than a lapsed pin. This is the only warning + before that. + + **A signal, never a verdict.** A superseded pin keeps verifying until the + certificates actually rotate, and that window is the only chance to refresh + without an outage — so folding this into `LotlRejected` would refuse documents + that verify perfectly and turn the early warning into the thing it exists to + prevent. `a_superseded_pin_does_not_refuse_a_document_that_verifies` pins that. + + **`Unknown` is not `Current`.** A document naming no notice cannot be checked, + and reporting it as up to date is how a staleness signal goes quiet at the + moment it matters. + + Reported and logged: the caller that most needs to act on it is an operator + reading logs, not the code holding the `VerifiedLotl`. + + The check rests on the document listing its notice **first** in + `SchemeInformationURI`, ahead of the pivot chain and twenty-three per-language + legal notices. That ordering is asserted against the real published document + rather than trusted, so if it ever changes the result is a red test rather than + a comparison against a pivot URL. + - **A life status that contradicts its own lineage is now reported.** The plausibility lint gains `lineage.life_status_unsupported`, from `dpp_rules::lineage::check_life_status_consistency`: a unit claiming diff --git a/crates/dpp-seal/src/trustlist/mod.rs b/crates/dpp-seal/src/trustlist/mod.rs index 76f0be1a..21e0305a 100644 --- a/crates/dpp-seal/src/trustlist/mod.rs +++ b/crates/dpp-seal/src/trustlist/mod.rs @@ -95,6 +95,6 @@ pub use fetch::{ pub use model::{ListedProvider, ListedService, TrustedListPointer, UnverifiedTrustedList}; pub use parse::{parse_lotl, parse_trusted_list}; pub use verify::{ - LotlRejected, TrustedListRejected, VerifiedLotl, VerifiedTrustedList, verify_lotl, - verify_lotl_with, verify_trusted_list, + AnchorFreshness, LotlRejected, TrustedListRejected, VerifiedLotl, VerifiedTrustedList, + verify_lotl, verify_lotl_with, verify_trusted_list, }; diff --git a/crates/dpp-seal/src/trustlist/verify.rs b/crates/dpp-seal/src/trustlist/verify.rs index aab6512e..87956968 100644 --- a/crates/dpp-seal/src/trustlist/verify.rs +++ b/crates/dpp-seal/src/trustlist/verify.rs @@ -67,6 +67,88 @@ impl std::fmt::Display for LotlRejected { impl std::error::Error for LotlRejected {} +/// Whether the pinned anchor is still the notice the LOTL itself names. +/// +/// **Not part of the verdict.** A superseded pin keeps verifying until the +/// Commission actually rotates the signing certificates, which is exactly why +/// this is worth reporting: the window between "a newer notice exists" and "the +/// old certificates stop being used" is the only chance to refresh without an +/// outage. Folding it into [`LotlRejected`] would refuse documents that verify +/// perfectly today. +/// +/// The failure it exists to pre-empt is unpleasant: a pin nobody refreshes +/// eventually meets a LOTL signed by a certificate the notice no longer names, +/// which fails closed as [`LotlRejected::NotAnchored`] — on a date nobody has in +/// a calendar, looking like an outage rather than a lapsed pin. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum AnchorFreshness { + /// The LOTL names the notice this build is pinned to. + Current, + /// The LOTL names a different notice, so the Commission has republished. + /// + /// Carries what the document named so an operator can go and read it, + /// rather than being told only that their pin is wrong. + Superseded { + /// The notice the LOTL names as currently in force. + lotl_names: String, + }, + /// The document names no notice at all, so the question cannot be answered. + /// + /// Distinct from [`Current`](Self::Current) deliberately. Treating "could + /// not tell" as "up to date" is how a staleness signal goes quiet at the + /// moment it is most needed — the same fail-closed direction the rest of + /// this module takes. + Unknown, +} + +impl std::fmt::Display for AnchorFreshness { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Current => f.write_str("the pinned notice is the one in force"), + Self::Superseded { lotl_names } => write!( + f, + "the list of lists names {lotl_names} as the notice in force, which is not the \ + one this build pins — refresh the anchor from it before the signing \ + certificates rotate" + ), + Self::Unknown => { + f.write_str("the list of lists names no notice, so the pin cannot be checked") + } + } + } +} + +/// The notice a LOTL names as currently in force, compared against `pinned`. +/// +/// The document lists its notice **first** in `SchemeInformationURI`, ahead of +/// the pivot chain and the per-language legal notices. That ordering is what +/// makes this cheap; it is also the only thing this reads, so a document that +/// reorders those entries would report `Superseded` rather than silently +/// comparing the wrong one. +pub(super) fn anchor_freshness(xml: &str, pinned: &str) -> AnchorFreshness { + let Ok(doc) = Document::parse(xml) else { + return AnchorFreshness::Unknown; + }; + let named = doc + .descendants() + .find(|n| n.is_element() && n.tag_name().name() == "SchemeInformationURI") + .and_then(|n| { + n.children() + .find(|c| c.is_element() && c.tag_name().name() == "URI") + }) + .and_then(|n| n.text()) + .map(str::trim) + .filter(|s| !s.is_empty()); + + match named { + None => AnchorFreshness::Unknown, + Some(uri) if uri == pinned => AnchorFreshness::Current, + Some(uri) => AnchorFreshness::Superseded { + lotl_names: uri.to_owned(), + }, + } +} + /// A list of trusted lists whose signature has been verified against the anchor. /// /// The type exists so a verified document cannot be passed where an unverified @@ -80,6 +162,7 @@ impl std::error::Error for LotlRejected {} pub struct VerifiedLotl { pointers: Vec, signed_by: String, + anchor_freshness: AnchorFreshness, } impl VerifiedLotl { @@ -89,6 +172,16 @@ impl VerifiedLotl { &self.pointers } + /// Whether the pin this verified against is still the notice in force. + /// + /// Read it. A `Verified` document says the signature and the anchor agree + /// *today*; this says whether that will still be true after the next + /// rotation, and it is the only warning there is. + #[must_use] + pub fn anchor_freshness(&self) -> &AnchorFreshness { + &self.anchor_freshness + } + /// Base64 SHA-256 of the anchored certificate that signed it. /// /// For a trust report: it says *which* of the authorised certificates the @@ -176,10 +269,23 @@ pub fn verify_lotl_with(xml: &str, anchor: &LotlAnchor) -> Result {} + other => tracing::warn!( + pinned_notice = anchor.notice_celex(), + "trusted-list anchor: {other}" + ), + } + Ok(VerifiedLotl { pointers, signed_by: base64::engine::general_purpose::STANDARD .encode(::digest(&der)), + anchor_freshness: freshness, }) } diff --git a/crates/dpp-seal/src/trustlist/verify_tests.rs b/crates/dpp-seal/src/trustlist/verify_tests.rs index 22853b8f..bf5d07f3 100644 --- a/crates/dpp-seal/src/trustlist/verify_tests.rs +++ b/crates/dpp-seal/src/trustlist/verify_tests.rs @@ -1,6 +1,6 @@ //! Verifying the real list of trusted lists against the real anchor. -use super::verify::{LotlRejected, verify_lotl}; +use super::verify::{AnchorFreshness, LotlRejected, anchor_freshness, verify_lotl}; /// The EU list of trusted lists, as published. /// @@ -133,3 +133,101 @@ fn the_not_anchored_message_tells_an_operator_what_to_do() { assert!(rendered.contains("refresh"), "says what to do: {rendered}"); assert!(rendered.contains("AAAA"), "and what was offered"); } + +/// Whether the pinned anchor is still the notice the Commission names. +/// +/// The anchor is pinned from an Official Journal notice and the Commission +/// republishes that notice. A pin nobody refreshes eventually meets a LOTL +/// signed by a certificate it does not name, and fails closed on a date nobody +/// has in a calendar. This is the only warning before that. +mod anchor_freshness_signal { + use super::*; + + /// The assumption the whole check rests on, asserted against the real + /// document rather than trusted. + /// + /// The LOTL lists its notice **first** in `SchemeInformationURI`, ahead of + /// the pivot chain and twenty-three per-language legal notices. If that + /// ordering ever changed, this check would compare against a pivot URL and + /// report `Superseded` forever — noisy rather than silent, which is the + /// right way round, but still wrong. + #[test] + fn the_notice_is_the_first_entry_the_document_lists() { + let freshness = anchor_freshness(EU_LOTL, "https://eur-lex.europa.eu/eli/C/2026/1944/oj"); + assert_eq!( + freshness, + AnchorFreshness::Current, + "the first SchemeInformationURI entry is no longer the OJ notice" + ); + } + + /// The published document and this build's pin agree today. + /// + /// When this fails, the Commission has republished and the anchor needs + /// refreshing from the notice named in the failure — which is the whole + /// point of the signal, arriving as a red test rather than an outage. + #[test] + fn the_pinned_anchor_is_still_the_notice_in_force() { + let verified = verify_lotl(EU_LOTL).expect("the LOTL verifies"); + assert_eq!( + verified.anchor_freshness(), + &AnchorFreshness::Current, + "the pinned notice is no longer the one the LOTL names" + ); + } + + /// A superseded pin is named, and names what to go and read. + #[test] + fn a_superseded_pin_says_which_notice_replaced_it() { + let freshness = anchor_freshness(EU_LOTL, "https://eur-lex.europa.eu/eli/C/2019/276/oj"); + let AnchorFreshness::Superseded { lotl_names } = &freshness else { + panic!("a pin the document does not name must be reported: {freshness:?}"); + }; + assert_eq!(lotl_names, "https://eur-lex.europa.eu/eli/C/2026/1944/oj"); + assert!( + freshness.to_string().contains("refresh the anchor"), + "an operator has to be told what to do: {freshness}" + ); + } + + /// Freshness is a signal, never a verdict. + /// + /// The document that would report `Superseded` against an older pin is the + /// same document that verifies cleanly — which is the situation this exists + /// for. Refusing it would turn an early warning into the outage it is meant + /// to prevent. + #[test] + fn a_superseded_pin_does_not_refuse_a_document_that_verifies() { + assert!( + verify_lotl(EU_LOTL).is_ok(), + "the real LOTL verifies against the real anchor" + ); + assert!( + matches!( + anchor_freshness(EU_LOTL, "https://eur-lex.europa.eu/eli/C/2019/276/oj"), + AnchorFreshness::Superseded { .. } + ), + "and would report a stale pin, without that changing the verdict" + ); + } + + /// A document naming no notice is `Unknown`, not `Current`. + /// + /// Treating "could not tell" as "up to date" is how a staleness signal goes + /// quiet exactly when it matters — the same fail-closed direction the + /// capacity and date questions take elsewhere in this workspace. + #[test] + fn a_document_that_names_no_notice_is_not_reported_as_current() { + assert_eq!( + anchor_freshness( + "", + "https://example.invalid/notice" + ), + AnchorFreshness::Unknown + ); + assert_eq!( + anchor_freshness("not xml at all", "https://example.invalid/notice"), + AnchorFreshness::Unknown + ); + } +}