From 02edcad5af3d299156fe16c7199e237fc35788bc Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 19 May 2026 19:59:56 +0200 Subject: [PATCH 01/16] add LoTe filter service for extracting certs --- .../etsi/verification/LoTEFilterService.kt | 53 +++++++++++++++++++ .../at/asitplus/etsi/VerificationTest.kt | 14 +++++ 2 files changed, 67 insertions(+) create mode 100644 etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt create mode 100644 etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt new file mode 100644 index 000000000..e70af4d0d --- /dev/null +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt @@ -0,0 +1,53 @@ +package at.asitplus.etsi.verification + +import at.asitplus.etsi.ListOfTrustedEntities +import at.asitplus.etsi.TEName +import at.asitplus.signum.indispensable.asn1.Asn1Primitive +import at.asitplus.signum.indispensable.asn1.Asn1String +import at.asitplus.signum.indispensable.pki.AttributeTypeAndValue +import at.asitplus.signum.indispensable.pki.X509Certificate + +class LoTEFilterService { + + fun extractTrustedCertificates(lote: ListOfTrustedEntities, criteria: LoTEFilterCriteria): List { + val entities = lote.trustedEntitiesList ?: return emptyList() + + return entities.flatMap { entity -> + val providerName = entity.trustedEntityInformation.teName + + entity.trustedEntityServices + .filter { it.serviceInformation.serviceTypeIdentifier?.string == criteria.expectedServiceType } + .flatMap { service -> service.serviceInformation.serviceDigitalIdentity.x509Certificates ?: emptyList() } + .filter { cert -> cert.hasMatchingOrganization(providerName) } + .map { cert -> TrustedCertificate(cert, providerName, criteria.expectedServiceType) } + } + } + + // Checks if any organization name matches the provider's TEName + private fun X509Certificate.hasMatchingOrganization(providerName: TEName): Boolean { + val orgName = tbsCertificate.subjectName + .flatMap { it.attrsAndValues } + .filterIsInstance() + .firstOrNull() + ?.asStringOrNull() ?: return false + + return providerName.any { it.value.equals(orgName, ignoreCase = true) } + } + private fun AttributeTypeAndValue.Organization.asStringOrNull(): String? = when (val element = value) { + is Asn1Primitive -> runCatching { Asn1String.decodeFromTlv(element).value }.getOrNull() + else -> element.toString() + } +} + +data class TrustedCertificate( + val certificate: X509Certificate, + val providerName: TEName, + val serviceType: String +) + +data class LoTEFilterCriteria( + val expectedLoTEType: String, + val expectedServiceType: String, + val enforceActiveStatus: Boolean = false, + val activeStatusUri: String = "http://uri.etsi.org/19602/PubEAAProvidersList/SvcStatus/notified" +) \ No newline at end of file diff --git a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt new file mode 100644 index 000000000..17c912bc3 --- /dev/null +++ b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt @@ -0,0 +1,14 @@ +package at.asitplus.etsi + +import de.infix.testBalloon.framework.core.testSuite +import io.matthewnelson.encoding.base64.Base64 + +val VerificationTest by testSuite { + + val pidLote = "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.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.FVowzg24-dFWPN7OzSoP_9yvtSNUplp0G_3hi8UGB_BmezQA9sBev1u_Iam7HP0vOjX08mrGkK-hULftG7M2r1fKLHr02mhNaEhUtp-y8GeTJh1Qatf897j7l7QVeZBP2Cm-TyFcZEVbvAjE3c3Zm3H9V9jbqv8c0wqYVdGNMQtJNUdNn3ZUyo8XOf5Eyx_YvdCK8Nd5nqtquBIViG_-qxlaW3qtkILrT0Y3FrvfIkhwLMtb1-W3mGb_g4v5-9N4oHFdLhFW3zx7gVms3NTbgslvoZV6BPrInFlgrb2qZGSyNgUXZ0RW0OTwrZ-226QVj5AZhM_r9bSzSLMvyJeot8DA_wr94G-JpHUk7YexwXdVFAGHFf0e44qBde7UtQAY4Qmo3nYJzRIk5vfVb0mUD2-uZ2OORQ1_Rx69v_VnLeHY1y-m8lnO350tmmbByxVLQrHAs12tpZ_3TQbrox2OWIwhSPnuJMPyOpGvfHqr_8fRdQFxELP8bNUk3F2Ag8f9QigAMAX317MeHJAkIfvw59z2jZfb-y5X4FR4iLPbNC0hs-1QgNO6Wu2EtP25Fc-b22fsr-kk1We6l-AV-2pmlv3so3RVFdSWxITWFmfKuvFX6HRly-eWVYzGJwzuLh2BA0Lw9tHP4aMF7ZdwlIMIjXlKD-fBJCZzWsamggASpaA" + + test("test deserialization") { + val parts = pidLote.split(".") + val encodedPayload = parts[1] + } +} \ No newline at end of file From bf9c15d150c9300e3764724d38e08ec99d3255dd Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Wed, 20 May 2026 12:05:29 +0200 Subject: [PATCH 02/16] add basic validation logic --- .../at/asitplus/wallet/lib/LoTEValidator.kt | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt new file mode 100644 index 000000000..2ce92c8a6 --- /dev/null +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt @@ -0,0 +1,60 @@ +package at.asitplus.etsi.verification + +import at.asitplus.signum.indispensable.X509SignatureAlgorithm +import at.asitplus.signum.indispensable.pki.CertificateChain +import at.asitplus.signum.indispensable.pki.X509Certificate +import at.asitplus.signum.indispensable.requireSupported +import at.asitplus.signum.supreme.sign.verifierFor +import at.asitplus.signum.supreme.sign.verify +import kotlin.time.Clock +import kotlin.time.Instant + +/** + * Verifies if this leaf certificate is directly signed and trusted by any anchor in the [trustStore]. + * Enforces strict timeliness, cryptographic integrity, and anchor constraints. + */ +fun X509Certificate.isDirectlyTrustedBy( + trustStore: CertificateChain, + date: Instant = Clock.System.now() +): Boolean { + if (!this.isValidAt(date)) return false + + return trustStore + .filter { anchor -> anchor.tbsCertificate.subjectName == this.tbsCertificate.issuerName } + .any { anchor -> + anchor.isValidAt(date) && anchor.isIssuerOf(this) + } +} + +/** + * Checks whether this certificate has expired at the specified [date]. + * + * @return `true` if the certificate is expired, `false` otherwise. + */ +fun X509Certificate.isExpired(date: Instant = Clock.System.now()): Boolean = + Instant.fromEpochSeconds(date.epochSeconds) > tbsCertificate.validUntil.instant + +/** + * Checks whether this certificate is not yet valid at the specified [date]. + * + * @return `true` if the certificate is not yet valid, `false` otherwise. + */ +fun X509Certificate.isNotYetValid(date: Instant = Clock.System.now()): Boolean = + Instant.fromEpochSeconds(date.epochSeconds) < tbsCertificate.validFrom.instant + + +/** + * Checks whether this certificate is valid at the specified [date]. + */ +fun X509Certificate.isValidAt(date: Instant = Clock.System.now()): Boolean = !(isExpired(date) || isNotYetValid(date)) + +fun X509Certificate.isIssuerOf(cert: X509Certificate): Boolean { + val verifier = (cert.signatureAlgorithm.requireSupported() as X509SignatureAlgorithm).verifierFor(this.decodedPublicKey.getOrThrow()).getOrElse { return false } + val signatureValid = verifier.verify( + cert.tbsCertificate.encodeToDer(), + cert.decodedSignature.getOrThrow() + ).isSuccess + + val issuerName = cert.tbsCertificate.issuerName + return signatureValid && issuerName == this.tbsCertificate.subjectName +} \ No newline at end of file From 7a4977f21c356b11dbf63b7df68733d8a19aff84 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Thu, 21 May 2026 14:04:01 +0200 Subject: [PATCH 03/16] change certificate deserialization to not throw in LoTE --- .../etsi/EtsiX509CertificateSerializer.kt | 16 +++++++++++----- .../at/asitplus/etsi/ServiceDigitalIdentity.kt | 8 ++++---- .../etsi/verification/LoTEFilterService.kt | 6 ++++-- .../kotlin/at/asitplus/etsi/VerificationTest.kt | 8 +++++--- 4 files changed, 24 insertions(+), 14 deletions(-) diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt index 1c010f7d1..8005cb01c 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt @@ -9,7 +9,7 @@ import kotlinx.serialization.descriptors.SerialDescriptor import kotlinx.serialization.encoding.Decoder import kotlinx.serialization.encoding.Encoder -class EtsiX509CertificateSerializer : KSerializer { +class EtsiX509CertificateSerializer : KSerializer { private val delegate = EtsiX509CertificateSerializationSurrogate.serializer() override val descriptor: SerialDescriptor get() = SerialDescriptor( @@ -19,8 +19,10 @@ class EtsiX509CertificateSerializer : KSerializer { override fun serialize( encoder: Encoder, - value: X509Certificate + value: X509Certificate? ) { + if (value == null) return encoder.encodeNull() + encoder.encodeSerializableValue( EtsiX509CertificateSerializationSurrogate.serializer(), EtsiX509CertificateSerializationSurrogate( @@ -29,9 +31,13 @@ class EtsiX509CertificateSerializer : KSerializer { ) } - override fun deserialize(decoder: Decoder) = decoder.decodeSerializableValue( - EtsiX509CertificateSerializationSurrogate.serializer(), - ).value + override fun deserialize(decoder: Decoder) : X509Certificate? = try { + decoder.decodeSerializableValue( + EtsiX509CertificateSerializationSurrogate.serializer(), + ).value + } catch (_: Exception) { + null + } @Serializable private data class EtsiX509CertificateSerializationSurrogate( diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt index 354232f58..cbfad313c 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt @@ -22,7 +22,7 @@ interface OtherId @Serializable data class ServiceDigitalIdentity( @SerialName(SerialNames.X509_CERTIFICATE) - val x509Certificates: List<@Serializable(with = EtsiX509CertificateSerializer::class) X509Certificate>? = null, + val x509Certificates: List<@Serializable(with = EtsiX509CertificateSerializer::class) X509Certificate?> = emptyList(), @SerialName(SerialNames.X509_SUBJECT_NAMES) val x509SubjectNames: List? = null, @SerialName(SerialNames.PUBLIC_KEY_VALUE) @@ -33,9 +33,9 @@ data class ServiceDigitalIdentity( val otherIds: List? = null, ) { init { - require(x509Certificates?.isNotEmpty() != false) { - "Expected at least 1 X509Certificate, but got 0." - } +// require(x509Certificates?.isNotEmpty() != false) { +// "Expected at least 1 X509Certificate, but got 0." +// } require(x509SubjectNames?.isNotEmpty() != false) { "Expected at least 1 X509SubjectName, but got 0." } diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt index e70af4d0d..487235abd 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt @@ -1,11 +1,13 @@ package at.asitplus.etsi.verification +import at.asitplus.etsi.EtsiX509CertificateSerializer import at.asitplus.etsi.ListOfTrustedEntities import at.asitplus.etsi.TEName import at.asitplus.signum.indispensable.asn1.Asn1Primitive import at.asitplus.signum.indispensable.asn1.Asn1String import at.asitplus.signum.indispensable.pki.AttributeTypeAndValue import at.asitplus.signum.indispensable.pki.X509Certificate +import kotlinx.serialization.Serializable class LoTEFilterService { @@ -18,7 +20,7 @@ class LoTEFilterService { entity.trustedEntityServices .filter { it.serviceInformation.serviceTypeIdentifier?.string == criteria.expectedServiceType } .flatMap { service -> service.serviceInformation.serviceDigitalIdentity.x509Certificates ?: emptyList() } - .filter { cert -> cert.hasMatchingOrganization(providerName) } + .filter { cert -> cert?.hasMatchingOrganization(providerName) == true } .map { cert -> TrustedCertificate(cert, providerName, criteria.expectedServiceType) } } } @@ -40,7 +42,7 @@ class LoTEFilterService { } data class TrustedCertificate( - val certificate: X509Certificate, + val certificate: @Serializable(with = EtsiX509CertificateSerializer::class) X509Certificate?, val providerName: TEName, val serviceType: String ) diff --git a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt index 17c912bc3..aab1a39d2 100644 --- a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt +++ b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt @@ -1,14 +1,16 @@ package at.asitplus.etsi +import at.asitplus.etsi.verification.TrustListLoader import de.infix.testBalloon.framework.core.testSuite import io.matthewnelson.encoding.base64.Base64 val VerificationTest by testSuite { - val pidLote = "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.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.FVowzg24-dFWPN7OzSoP_9yvtSNUplp0G_3hi8UGB_BmezQA9sBev1u_Iam7HP0vOjX08mrGkK-hULftG7M2r1fKLHr02mhNaEhUtp-y8GeTJh1Qatf897j7l7QVeZBP2Cm-TyFcZEVbvAjE3c3Zm3H9V9jbqv8c0wqYVdGNMQtJNUdNn3ZUyo8XOf5Eyx_YvdCK8Nd5nqtquBIViG_-qxlaW3qtkILrT0Y3FrvfIkhwLMtb1-W3mGb_g4v5-9N4oHFdLhFW3zx7gVms3NTbgslvoZV6BPrInFlgrb2qZGSyNgUXZ0RW0OTwrZ-226QVj5AZhM_r9bSzSLMvyJeot8DA_wr94G-JpHUk7YexwXdVFAGHFf0e44qBde7UtQAY4Qmo3nYJzRIk5vfVb0mUD2-uZ2OORQ1_Rx69v_VnLeHY1y-m8lnO350tmmbByxVLQrHAs12tpZ_3TQbrox2OWIwhSPnuJMPyOpGvfHqr_8fRdQFxELP8bNUk3F2Ag8f9QigAMAX317MeHJAkIfvw59z2jZfb-y5X4FR4iLPbNC0hs-1QgNO6Wu2EtP25Fc-b22fsr-kk1We6l-AV-2pmlv3so3RVFdSWxITWFmfKuvFX6HRly-eWVYzGJwzuLh2BA0Lw9tHP4aMF7ZdwlIMIjXlKD-fBJCZzWsamggASpaA" test("test deserialization") { - val parts = pidLote.split(".") - val encodedPayload = parts[1] + val loader = TrustListLoader() + + val list = loader.fetchTrustList() + println(list) } } \ No newline at end of file From 06017a98f568613c12afed33d5b45930f54260e6 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Fri, 22 May 2026 12:04:19 +0200 Subject: [PATCH 04/16] fix bug in x509Cert json serializer and add tests for filtering --- .../etsi/EtsiX509CertificateSerializer.kt | 30 +- .../etsi/verification/LoTEFilterService.kt | 7 +- .../etsi/verification/TrustListLoader.kt | 90 + .../kotlin/at/asitplus/etsi/LoTEFilterTest.kt | 7053 +++++++++++++++++ .../at/asitplus/etsi/VerificationTest.kt | 16 - ...LoTEValidator.kt => TrustListValidator.kt} | 2 +- 6 files changed, 7172 insertions(+), 26 deletions(-) create mode 100644 etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt create mode 100644 etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt delete mode 100644 etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt rename vck/src/commonMain/kotlin/at/asitplus/wallet/lib/{LoTEValidator.kt => TrustListValidator.kt} (98%) diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt index 8005cb01c..ea51fc936 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt @@ -6,8 +6,13 @@ import kotlinx.serialization.KSerializer import kotlinx.serialization.SerialName import kotlinx.serialization.Serializable import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.descriptors.buildClassSerialDescriptor import kotlinx.serialization.encoding.Decoder import kotlinx.serialization.encoding.Encoder +import kotlinx.serialization.json.JsonDecoder +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.jsonPrimitive +import kotlin.io.encoding.Base64 class EtsiX509CertificateSerializer : KSerializer { private val delegate = EtsiX509CertificateSerializationSurrogate.serializer() @@ -31,10 +36,27 @@ class EtsiX509CertificateSerializer : KSerializer { ) } - override fun deserialize(decoder: Decoder) : X509Certificate? = try { - decoder.decodeSerializableValue( - EtsiX509CertificateSerializationSurrogate.serializer(), - ).value + override fun deserialize(decoder: Decoder): X509Certificate? = try { + when (decoder) { + is JsonDecoder -> { + val jsonObject = decoder + .decodeJsonElement() + .jsonObject + + val base64 = jsonObject[ + EtsiX509CertificateSerializationSurrogate.SerialNames.VALUE + ]?.jsonPrimitive?.content ?: return null + + val bytes = Base64.Default.decode(base64) + + X509Certificate.decodeFromByteArray(bytes) + } + else -> { + decoder.decodeSerializableValue( + EtsiX509CertificateSerializationSurrogate.serializer(), + ).value + } + } } catch (_: Exception) { null } diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt index 487235abd..d41005b8a 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt @@ -19,8 +19,8 @@ class LoTEFilterService { entity.trustedEntityServices .filter { it.serviceInformation.serviceTypeIdentifier?.string == criteria.expectedServiceType } - .flatMap { service -> service.serviceInformation.serviceDigitalIdentity.x509Certificates ?: emptyList() } - .filter { cert -> cert?.hasMatchingOrganization(providerName) == true } + .flatMap { service -> service.serviceInformation.serviceDigitalIdentity.x509Certificates } +// .filter { cert -> cert?.hasMatchingOrganization(providerName) == true } .map { cert -> TrustedCertificate(cert, providerName, criteria.expectedServiceType) } } } @@ -48,8 +48,5 @@ data class TrustedCertificate( ) data class LoTEFilterCriteria( - val expectedLoTEType: String, val expectedServiceType: String, - val enforceActiveStatus: Boolean = false, - val activeStatusUri: String = "http://uri.etsi.org/19602/PubEAAProvidersList/SvcStatus/notified" ) \ No newline at end of file diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt new file mode 100644 index 000000000..adcb5e98d --- /dev/null +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt @@ -0,0 +1,90 @@ +package at.asitplus.etsi.verification + +import at.asitplus.etsi.ListOfTrustedEntities +import at.asitplus.signum.indispensable.josef.JwsSigned +import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer +import io.ktor.client.HttpClient +import io.ktor.client.call.body +import io.ktor.client.plugins.contentnegotiation.ContentNegotiation +import io.ktor.client.request.accept +import io.ktor.client.request.get +import io.ktor.client.statement.bodyAsText +import io.ktor.http.ContentType +import io.ktor.http.HttpStatusCode +import io.ktor.serialization.kotlinx.json.json +import io.ktor.utils.io.InternalAPI +import io.matthewnelson.encoding.base64.Base64 +import kotlinx.serialization.json.Json +import io.ktor.util.decodeBase64String +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.builtins.serializer +import kotlinx.serialization.json.decodeFromJsonElement +import kotlinx.serialization.json.jsonObject + + +class TrustListLoader { + private val httpClient = HttpClient { + install(ContentNegotiation) { + json(joseCompliantSerializer) + } + } + + /** + * Fetches the Trust List across any target platform (iOS, Android, JVM, etc.) + */ + @OptIn(InternalAPI::class) + suspend fun fetchTrustList(): ListOfTrustedEntities? { + val url = "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" + + val response = httpClient.get(url) { + accept(ContentType.Application.Json) + } + + val jwsCompactString = response.body() + + // Deserialize the JWS directly. + // JwsSigned handles the Base64Url decoding and delegates JSON parsing to your jsonParser. + val jws = JwsSigned.deserialize( + TrustListJwsPayload.serializer(), + jwsCompactString, + joseCompliantSerializer + ).getOrThrow() + + // The deserialized data is available safely on the payload property + val ret = jws.payload.loTe + return ret +// val jwsCompactString = response.bodyAsText().trim('"', ' ', '\n', '\r') +// +// val parts = jwsCompactString.split(".") +// require(parts.size == 3) { +// "The response is not a valid JWS token format. Got ${parts.size} parts." +// } +// +// // 3. Extract and fix the missing Base64 padding on the payload +// var base64Payload = parts[1] +// .replace('-', '+') +// .replace('_', '/') +// +// // 4. Decode directly to a String using Ktor's KMP utility +// val decodedJsonPayload = base64Payload.decodeBase64String() +// +// // 5. Deserialize using the class-level jsonParser +// val rootElement = jsonParser.parseToJsonElement(decodedJsonPayload) +// +// // 6. Extract the "LoTE" object from the root +// val loTeElement = rootElement.jsonObject["LoTE"] +// ?: throw IllegalArgumentException("The decoded JSON does not contain the 'LoTE' key.") +// +// // 7. Deserialize ONLY the inner object into your class +// val ret = jsonParser.decodeFromJsonElement(loTeElement) +// return ret + } +} + +@Serializable +data class TrustListJwsPayload( + @SerialName("LoTE") + val loTe: ListOfTrustedEntities +) + diff --git a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt new file mode 100644 index 000000000..29c3174a4 --- /dev/null +++ b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt @@ -0,0 +1,7053 @@ +package at.asitplus.etsi + +import at.asitplus.etsi.verification.LoTEFilterCriteria +import at.asitplus.etsi.verification.LoTEFilterService +import at.asitplus.testballoon.withData +import de.infix.testBalloon.framework.core.testSuite +import io.kotest.matchers.shouldNotBe +import kotlinx.serialization.json.Json + +val VerificationTest by testSuite { + + val pidProvidersOriginal = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 4, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUPIDProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/pid-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/PIDProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/PIDProviders/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-17T13:14:02Z", + "NextUpdate": "2026-10-16T13:14:02Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Agence Nationale des Titres Sécurisés" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-2356568" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3465", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fr" + }, + { + "lang": "en", + "uriValue": "tel:+337848346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - Bevisporten" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5788", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - PID-utsteder" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3478", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digi- ja väestötietovirasto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFI-8567" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5685", + "Country": "FI" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fi" + }, + { + "lang": "en", + "uriValue": "tel:+358348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fi" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FI" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fi" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse PID Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "9678", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse Pub EAA Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5784", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_4" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "AMA - Agência para a Modernização Administrativa" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATPT-98765" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "PT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.pt" + }, + { + "lang": "en", + "uriValue": "tel:+35134567" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.pt" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/PT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_pt" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIC3zCCAoWgAwIBAgIUcSydOyasuB5uNjr9rj5tPAhpbQUwCgYIKoZIzj0EAwIwejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMB4XDTI0MDgyMzE4MTQ0N1oXDTMzMTExOTE4MTQ0NlowejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQQp1ekgl4ztbyvAEHQcHjiIwNRbELpVBzqXiGP2AZdhCP0qgEQ5Ud2hb0fbrE2/hEtiZmw0ppGX37g/wx+VLaOB6DCB5TASBgNVHRMBAf8ECDAGAQH/AgEAMB8GA1UdIwQYMBaAFNl5BlM1kkgig634oJOTlZRNJbezMBYGA1UdJQEB/wQMMAoGCCuBAgIAAAEHMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHBzOi8vcHJlcHJvZC5wa2kuYW1hLnByb2pqLmV1L2NybC9waWRfQ0FfMDEuY3JsMB0GA1UdDgQWBBTZeQZTNZJIIoOt+KCTk5WUTSW3szAOBgNVHQ8BAf8EBAMCAQYwIgYDVR0SBBswVIZSaHR0cHM6Ly93d3cuYW1hLmdvdi5wdC8wCgYIKoZIzj0EAwIDSAAwRQIhAPlr1TTIv8pTKOY08FpKrpNsFLj9gKIagDIUHcDPjy6iAiBL8GUS5H5NcHhTEjJxxEMX9CVuFfVhvRCssbaCV3RwsA==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-45678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+4378901" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_at_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "IDAKTO IACA 4" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-567890" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+3345678" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "ISO Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-0987" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain2.at" + }, + { + "lang": "en", + "uriValue": "tel:+3320390" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_at_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Bundesdruckerei GmbH" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATDE-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "DE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.de" + }, + { + "lang": "en", + "uriValue": "tel:+49320390" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.de" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/DE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_de_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+3698709" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_hu_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "TEST Authority" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEE-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "EE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.ee" + }, + { + "lang": "en", + "uriValue": "tel:+37298709" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.ee" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/EE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_ee" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "GRNET" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEL-77432" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53554", + "Country": "EL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.el" + }, + { + "lang": "en", + "uriValue": "tel:+30293239487" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.el" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/EL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_el" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "PID Provider1" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "PAAP Test Name1" + }, + { + "lang": "en", + "value": "VATPL-5170359458" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test", + "Locality": "Locality", + "StateOrProvince": "", + "PostalCode": "", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.se" + }, + { + "lang": "en", + "uriValue": "tel:+9988" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Test Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUTCCAjmgAwIBAgIQNx1PCl0yvLFIAPW3ueQiwzANBgkqhkiG9w0BAQsFADAvMRYwFAYDVQQKDA1QSUQgUHJvdmlkZXIxMRUwEwYDVQQDDAxOYW1lVGVzdENlcnQwHhcNMjUwOTI1MTQxNzUwWhcNMjYwOTI1MTQyNzUwWjAvMRYwFAYDVQQKDA1QSUQgUHJvdmlkZXIxMRUwEwYDVQQDDAxOYW1lVGVzdENlcnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCX9gPZbuZHoJQbrxXOtIWYiQw5a1DgSKe4h3MNXiE7728oHYHIhV0ZoU3SX70XJpWrNsudo7bVMLoHN2UANkjX6SO5LR1OL7oAo3NFD9974GlQxLg5QmrJacbgg1NtFLTHq5c8SLzG3fHc9DJ94vB/lGxP7rBBOzQLp3j9h1muLYl+ZGroZjZOj7d7uK0hK0d4UWkDWb2n2K6kC1PN7zwTLxchEF1oppPFjogF/7Gq7OWFiQy3LS6h+marlY6FxFmU9tq7Uu2hxJF2tFMPVZsMUHEluUZFW25VH30Y3LtiSvlRQY1wiakTuE2pRF3VvXi3Kgx2O15VdvbCadZOK/8hAgMBAAGjaTBnMA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwFwYDVR0RBBAwDoIMTmFtZVRlc3RDZXJ0MB0GA1UdDgQWBBSKjzSwKcYg/s+/jOq+rm0NhUDC1DANBgkqhkiG9w0BAQsFAAOCAQEARyAF6yKL2xVPRVIA/o+YBdEmTRpnFAIPIvjC6hCfKpTz/hpMzHuuuTxU8oMg6mHyeL6fOGhLodXQMqkoJZMEpOwftnpHmIXR5+BHZaH7/Ga/6zIa53suiqydmuEo+FxDrBK6s42v/O2mB66hptTJ3cg3aqXEXeV5w5uAbTLlrCpaggXFBjZuR3E8xj8MGax4BUL8mBW+24XaRA/APSPnLwVlyJ95kiJC9R/9MH1t7wRxfftI7wuqQLi4hb3Nl/Zo1aL66txelX/TLkdq4f+1Ql1Pfzz60nIqk3oICCSg89acEx6o1tAfguBid50cHnLxaTBe6g8KFwXv+5PUTZ1Fug==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Test Service 2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDNjCCAh6gAwIBAgIQXRnxamTIT4JGgTnOaCBRQjANBgkqhkiG9w0BAQsFADAuMRgwFgYDVQQKDA9QQUFQIFRlc3QgTmFtZTExEjAQBgNVBAMMCVRlc3RDZXJ0MTAeFw0yNTA5MTgxMDM2MDFaFw0zMDA5MTgxMDQ2MDFaMC4xGDAWBgNVBAoMD1BBQVAgVGVzdCBOYW1lMTESMBAGA1UEAwwJVGVzdENlcnQxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlLCnGRUwbkiOcFnI9f7CFfFzxOfsgNkI6x/S7BXrTesp+VgP/PPO+yILV42kNBDFO+YUcd5T9Offv+s6YfU1YfTCh1D4UXio9s9b8iYFiRCkB7s5bqHAYb9uc2zDpt/t+heuRt7TjGGJqdykpRRjcNP56TMtqfmhtQhvG1LYJzj1HulsmjGvdJVSkreeOxkzy4GCB/6UENqnWZhPdGvqY5tzZ2GXUwpN7mDFP1zA5unLgVQIcHmXtWYAYllnNu7IV9mBq/g1XvngzyWefMmKLqf791AgXY0dd9G6JlOOvkB5Y4jMHAT6DzNyoYiQrigTQxI2lWyuqYxTqhhY201wqQIDAQABo1AwTjAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMB0GA1UdDgQWBBTlGtpzx3x9ErCwLv73FslxFD6IPTANBgkqhkiG9w0BAQsFAAOCAQEAUQZ5Qeb8mcZpMub4I5NF5bNox3yVPwPThzf6VwBVvaaHsm2xZoWXSpKBlyiCmFoQINJ5PHglgZOIVdcCU3SKfeHhffLhxIW+qTC6DZ05DZyuL4+FFVMH8/SKOrlLbT3x1SM5u8iEWMFPFMfkGDW8Xq6vWpobuDg5eVyYjvj29wCZuyygfaj1cRr21/aKefOksw8rc97yTzzHNPcHjjBqFZv8Pq4TAMExgV0a6h8tnnk8AK2+MSy0SOHbrCj7khm2Q5+gOaPXfwzVHCoJTuEfRDSF96+IlX/2nr+eVwvpfcMtr+01LnRh/actoLGOybsM/1H9jMGxF4VqsQwBiMwfxQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "https://supplypoints", + "ServiceType": "type:type" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "information:uri" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val walletProvidersOriginal = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUWalletProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/wallet-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/WalletProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/WalletProvidersList/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T11:23:10Z", + "NextUpdate": "2026-10-02T11:23:10Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "PagoPA Wallet Provider Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATIT-123456789" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test street", + "Locality": "Test locality", + "StateOrProvince": "Test province", + "PostalCode": "12345", + "Country": "IT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.it" + }, + { + "lang": "en", + "uriValue": "tel:+39123456789" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.it" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/IT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_eudiw_solution_it" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICUDCCAfWgAwIBAgIUONlIPSqyFQVjT6+yy1zAFLS+fOUwCgYIKoZIzj0EAwIwfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMB4XDTI1MTEyMTE2MDcxOFoXDTM1MTExOTE2MDcxOFowfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsOCKDPMrqG3DKLHAEqkutBKCBHlSmuyeQGkLL95EW4oAzqVd+1aVPfXGNKSE6dgGb2wbrcqNz/wLyoTdBh3pkaNTMFEwHQYDVR0OBBYEFFdzfeaqb/ETC5YoB4Od5h4jVD7VMB8GA1UdIwQYMBaAFFdzfeaqb/ETC5YoB4Od5h4jVD7VMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSQAwRgIhAP8LhOOEB8HPNx0sobIBQgS3Ej1rtzXcx4hggAfyFFTJAiEAmJMJA1tgB/kl2gmH5TKH2R4QaWeHmgAZSFQcdZ7yEFM=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "ojeu:eudiw:ref_eudiw_solution_it" + } + ] + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test street", + "Locality": "Test locality", + "StateOrProvince": "Test province", + "PostalCode": "123456", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36123456" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wallet_solution_ojeu_hu" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "ojeu:eudiw:ref_wallet_solution_hu" + } + ] + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Wallet Notification" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wallet@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+4235002211" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/information" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/PL" + } + ], + "TEInformationExtensions": [ + { + "OtherAssociatedBodies": [ + { + "AssociatedBodyName": [ + { + "lang": "en", + "value": "Wallet Notification Body" + } + ], + "AssociatedBodyTradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration Wallet Body" + }, + { + "lang": "en", + "value": "VATLI-3333" + } + ], + "AssociatedBodyAddress": { + "AssociatedBodyPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2A", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "AssociatedBodyElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wallet-body@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+42350022112" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/body" + } + ] + }, + "AssociatedBodyInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/body/information" + } + ] + } + ] + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Wallet Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/" + } + ], + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "REF:1234" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val wrpacProvidersOriginal = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUWRPACProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/WRPACProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/WRPACProvidersList/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T09:21:34Z", + "NextUpdate": "2026-10-01T09:21:34Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse RP Access CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "1234", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.no" + }, + { + "lang": "en", + "uriValue": "tel:+47987654" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICuzCCAmGgAwIBAgIJAKcp7ByPxFNUMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNTA5MDc1NjU0WhcNMzAwNDI5MDc1NjU0WjBkMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxKjAoBgNVBAMTIWVpZGFzMnNhbmRrYXNzZSBSUCBBY2Nlc3MgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4OQr5vpRMvcYZs46LkpdDgVQ9V+9E/Gx3Io2jqm+g/43/0b2Ns9oSRv1VpY/vYSI/O6JWylRQ+MNk6V3DfQv2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUUcgCJYAwgpE7JCLUm9xeoainXcwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDSAAwRQIgfuk68h7gRHYXzBuddxFEUGl1eYtQgMCMKcw6D1kVjzgCIQC91xg+yGdocsoPmIGACivfYZAftiQXGEjHdid9RZOX1g==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Idakto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "1234", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+33234567" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_fr" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICgjCCAiegAwIBAgIUafRAIleaQOm9jZLiIML9FeOWd9cwCgYIKoZIzj0EAwIwczELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZSQU5DRTEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJZGFrdG8xDjAMBgNVBAsMBVN0ZWFtMSEwHwYDVQQDDBhyZWFkZXItaXNzdWVyQGlkYWt0by5jb20wHhcNMjUwNzI1MTQ0NzI1WhcNMzAwNzI0MTQ0NzI1WjBzMQswCQYDVQQGEwJGUjEPMA0GA1UECAwGRlJBTkNFMQ8wDQYDVQQHDAZBbmdlcnMxDzANBgNVBAoMBklkYWt0bzEOMAwGA1UECwwFU3RlYW0xITAfBgNVBAMMGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCq6dkUsfqjCByvS+UM/FDOgjO5fbB6aEesAgWmiMrSJQybQnAGSOySr0V+E0puM3eMaLy4DzsGLW0LX6J+vRLOjgZgwgZUwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJ57lkHy09w59xHQDk4y9ubmup5VMCsGA1UdEQQkMCKCIG9wZW5pZDR2cC5kcnVrcXMuYXNnYXJkLmlkZW52LmZyMCMGA1UdEgQcMBqBGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9hIBNw8GI7E5z/NZI/3CUMZjndoKGg+2o0lh8/6gY30CIQCiUgMnIib46Ypi4IryQOn282zPWrTWQFwIebwASeG9+w==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36567890" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_hu" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-45678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+43789012" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_at" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICJzCCAc6gAwIBAgIUSvMftn/oM3etHjE7hdIBl6tWMV8wCgYIKoZIzj0EAwIwMzELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMRQwEgYDVQQDDAtWYWxlcmEgSUFDQTAeFw0yNTA2MjYwODI0MDJaFw0yNjA2MjYwODI0MDJaMDMxCzAJBgNVBAYTAkFUMQ4wDAYDVQQKDAVBLVNJVDEUMBIGA1UEAwwLVmFsZXJhIElBQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQmm+pmyUxx/x2eD131E8HhvNkhsfYQXzefZlxgLXQPqCOxO+VPOXVOKL0dUy+kHyT5IP/NOAh038coAVOgGPT4o4G/MIG8MBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMCIGA1UdEgQbMBmGF2h0dHBzOi8vd2FsbGV0LmEtc2l0LmF0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHBzOi8vd2FsbGV0LmEtc2l0LmF0L2NybC8xLmNybDAfBgNVHSMEGDAWgBSDGoj0XuXE3qEVTmPvKSvIvR36ijAdBgNVHQ4EFgQUgxqI9F7lxN6hFU5j7ykryL0d+oowCgYIKoZIzj0EAwIDRwAwRAIgS9XcYA4Be5gDIdHmMOgJ3AeS44gT4bgVgsg/D5+WXS8CIAxJgi3nhGrVMj9SszehLorR2rR5FO5RZgITAaOIGSNP" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "WRPAC Provider - failing conformance checks" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "WRPAC Provider1" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wrpac@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+423887744" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/information" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "WRPAC Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/service/information" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val mdlProvidersOriginal = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://trust.ec.europa.eu/lists/mDL/mDLProvidersListType", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/mdl-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://trust.ec.europa.eu/lists/mDL/mDLProvidersListStatusDetn", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/schemerules" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T11:24:30Z", + "NextUpdate": "2026-10-01T11:24:30Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Agence Nationale des Titres Sécurisés" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-2356568" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3465", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fr" + }, + { + "lang": "en", + "uriValue": "tel:+337848346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/mDLProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - Bevisporten" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5788", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - mDL-utsteder" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3478", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA==" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digi- ja väestötietovirasto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFI-8567" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5685", + "Country": "FI" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fi" + }, + { + "lang": "en", + "uriValue": "tel:+358348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fi" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/FI" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fi" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse mDL Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "4332", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse Pub EAA Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "test", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_4" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "AMA - Agência para a Modernização Administrativa" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATPT-27373" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "PT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.pt" + }, + { + "lang": "en", + "uriValue": "tel:+35198765" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.pt" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/PT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_pt" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIC3zCCAoWgAwIBAgIUcSydOyasuB5uNjr9rj5tPAhpbQUwCgYIKoZIzj0EAwIwejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMB4XDTI0MDgyMzE4MTQ0N1oXDTMzMTExOTE4MTQ0NlowejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQQp1ekgl4ztbyvAEHQcHjiIwNRbELpVBzqXiGP2AZdhCP0qgEQ5Ud2hb0fbrE2/hEtiZmw0ppGX37g/wx+VLaOB6DCB5TASBgNVHRMBAf8ECDAGAQH/AgEAMB8GA1UdIwQYMBaAFNl5BlM1kkgig634oJOTlZRNJbezMBYGA1UdJQEB/wQMMAoGCCuBAgIAAAEHMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHBzOi8vcHJlcHJvZC5wa2kuYW1hLnByb2pqLmV1L2NybC9waWRfQ0FfMDEuY3JsMB0GA1UdDgQWBBTZeQZTNZJIIoOt+KCTk5WUTSW3szAOBgNVHQ8BAf8EBAMCAQYwIgYDVR0SBBswVIZSaHR0cHM6Ly93d3cuYW1hLmdvdi5wdC8wCgYIKoZIzj0EAwIDSAAwRQIhAPlr1TTIv8pTKOY08FpKrpNsFLj9gKIagDIUHcDPjy6iAiBL8GUS5H5NcHhTEjJxxEMX9CVuFfVhvRCssbaCV3RwsA==" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-37373" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+4398279" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_at_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "IDAKTO IACA 4" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-73829" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23343", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+33857302" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "ISO Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-90021" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "63823", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+33848209" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_at_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Bundesdruckerei GmbH" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATDE-82718" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "638382", + "Country": "DE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.de" + }, + { + "lang": "en", + "uriValue": "tel:+4971501" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/DE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_de_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "73824", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36019283" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_hu_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "TEST Authority" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEE-373091" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53242", + "Country": "EE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.ee" + }, + { + "lang": "en", + "uriValue": "tel:+372932394" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.ee" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/EE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_ee" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "GRNET" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEL-7283" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53242", + "Country": "EL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.el" + }, + { + "lang": "en", + "uriValue": "tel:+302932394" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.el" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/EL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_el" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "mDL Provider1" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-mdl@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+423887744" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/information" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "mDL Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/service/information" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + + val pidProvidersFixed = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 4, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUPIDProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/pid-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/PIDProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/PIDProviders/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-17T13:14:02Z", + "NextUpdate": "2026-10-16T13:14:02Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Agence Nationale des Titres Sécurisés" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-2356568" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3465", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fr" + }, + { + "lang": "en", + "uriValue": "tel:+337848346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fr_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - Bevisporten" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5788", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - PID-utsteder" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3478", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digi- ja väestötietovirasto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFI-8567" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5685", + "Country": "FI" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fi" + }, + { + "lang": "en", + "uriValue": "tel:+358348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fi" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FI" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_fi" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse PID Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "9678", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse Pub EAA Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5784", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_PID_solution_no_4" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "AMA - Agência para a Modernização Administrativa" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATPT-98765" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "PT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.pt" + }, + { + "lang": "en", + "uriValue": "tel:+35134567" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.pt" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/PT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_pt" + } + ], + "ServiceDigitalIdentity": { + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-45678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+4378901" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_at_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "IDAKTO IACA 4" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-567890" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+3345678" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "ISO Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-0987" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain2.at" + }, + { + "lang": "en", + "uriValue": "tel:+3320390" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_at_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Bundesdruckerei GmbH" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATDE-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "DE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.de" + }, + { + "lang": "en", + "uriValue": "tel:+49320390" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.de" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/DE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_de_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+3698709" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_hu_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "TEST Authority" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEE-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "EE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.ee" + }, + { + "lang": "en", + "uriValue": "tel:+37298709" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.ee" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/EE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_ee" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "GRNET" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEL-77432" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53554", + "Country": "EL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.el" + }, + { + "lang": "en", + "uriValue": "tel:+30293239487" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.el" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/EL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_pid_solution_el" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "PID Provider1" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "PAAP Test Name1" + }, + { + "lang": "en", + "value": "VATPL-5170359458" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test", + "Locality": "Locality", + "StateOrProvince": "", + "PostalCode": "", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.se" + }, + { + "lang": "en", + "uriValue": "tel:+9988" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/PIDProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Test Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUTCCAjmgAwIBAgIQNx1PCl0yvLFIAPW3ueQiwzANBgkqhkiG9w0BAQsFADAvMRYwFAYDVQQKDA1QSUQgUHJvdmlkZXIxMRUwEwYDVQQDDAxOYW1lVGVzdENlcnQwHhcNMjUwOTI1MTQxNzUwWhcNMjYwOTI1MTQyNzUwWjAvMRYwFAYDVQQKDA1QSUQgUHJvdmlkZXIxMRUwEwYDVQQDDAxOYW1lVGVzdENlcnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCX9gPZbuZHoJQbrxXOtIWYiQw5a1DgSKe4h3MNXiE7728oHYHIhV0ZoU3SX70XJpWrNsudo7bVMLoHN2UANkjX6SO5LR1OL7oAo3NFD9974GlQxLg5QmrJacbgg1NtFLTHq5c8SLzG3fHc9DJ94vB/lGxP7rBBOzQLp3j9h1muLYl+ZGroZjZOj7d7uK0hK0d4UWkDWb2n2K6kC1PN7zwTLxchEF1oppPFjogF/7Gq7OWFiQy3LS6h+marlY6FxFmU9tq7Uu2hxJF2tFMPVZsMUHEluUZFW25VH30Y3LtiSvlRQY1wiakTuE2pRF3VvXi3Kgx2O15VdvbCadZOK/8hAgMBAAGjaTBnMA4GA1UdDwEB/wQEAwIFoDAdBgNVHSUEFjAUBggrBgEFBQcDAgYIKwYBBQUHAwEwFwYDVR0RBBAwDoIMTmFtZVRlc3RDZXJ0MB0GA1UdDgQWBBSKjzSwKcYg/s+/jOq+rm0NhUDC1DANBgkqhkiG9w0BAQsFAAOCAQEARyAF6yKL2xVPRVIA/o+YBdEmTRpnFAIPIvjC6hCfKpTz/hpMzHuuuTxU8oMg6mHyeL6fOGhLodXQMqkoJZMEpOwftnpHmIXR5+BHZaH7/Ga/6zIa53suiqydmuEo+FxDrBK6s42v/O2mB66hptTJ3cg3aqXEXeV5w5uAbTLlrCpaggXFBjZuR3E8xj8MGax4BUL8mBW+24XaRA/APSPnLwVlyJ95kiJC9R/9MH1t7wRxfftI7wuqQLi4hb3Nl/Zo1aL66txelX/TLkdq4f+1Ql1Pfzz60nIqk3oICCSg89acEx6o1tAfguBid50cHnLxaTBe6g8KFwXv+5PUTZ1Fug==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Test Service 2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDNjCCAh6gAwIBAgIQXRnxamTIT4JGgTnOaCBRQjANBgkqhkiG9w0BAQsFADAuMRgwFgYDVQQKDA9QQUFQIFRlc3QgTmFtZTExEjAQBgNVBAMMCVRlc3RDZXJ0MTAeFw0yNTA5MTgxMDM2MDFaFw0zMDA5MTgxMDQ2MDFaMC4xGDAWBgNVBAoMD1BBQVAgVGVzdCBOYW1lMTESMBAGA1UEAwwJVGVzdENlcnQxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlLCnGRUwbkiOcFnI9f7CFfFzxOfsgNkI6x/S7BXrTesp+VgP/PPO+yILV42kNBDFO+YUcd5T9Offv+s6YfU1YfTCh1D4UXio9s9b8iYFiRCkB7s5bqHAYb9uc2zDpt/t+heuRt7TjGGJqdykpRRjcNP56TMtqfmhtQhvG1LYJzj1HulsmjGvdJVSkreeOxkzy4GCB/6UENqnWZhPdGvqY5tzZ2GXUwpN7mDFP1zA5unLgVQIcHmXtWYAYllnNu7IV9mBq/g1XvngzyWefMmKLqf791AgXY0dd9G6JlOOvkB5Y4jMHAT6DzNyoYiQrigTQxI2lWyuqYxTqhhY201wqQIDAQABo1AwTjAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMB0GA1UdDgQWBBTlGtpzx3x9ErCwLv73FslxFD6IPTANBgkqhkiG9w0BAQsFAAOCAQEAUQZ5Qeb8mcZpMub4I5NF5bNox3yVPwPThzf6VwBVvaaHsm2xZoWXSpKBlyiCmFoQINJ5PHglgZOIVdcCU3SKfeHhffLhxIW+qTC6DZ05DZyuL4+FFVMH8/SKOrlLbT3x1SM5u8iEWMFPFMfkGDW8Xq6vWpobuDg5eVyYjvj29wCZuyygfaj1cRr21/aKefOksw8rc97yTzzHNPcHjjBqFZv8Pq4TAMExgV0a6h8tnnk8AK2+MSy0SOHbrCj7khm2Q5+gOaPXfwzVHCoJTuEfRDSF96+IlX/2nr+eVwvpfcMtr+01LnRh/actoLGOybsM/1H9jMGxF4VqsQwBiMwfxQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/PID/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "https://supplypoints", + "ServiceType": "type:type" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "information:uri" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val walletProvidersFixed = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUWalletProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/wallet-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/WalletProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/WalletProvidersList/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T11:23:10Z", + "NextUpdate": "2026-10-02T11:23:10Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "PagoPA Wallet Provider Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATIT-123456789" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test street", + "Locality": "Test locality", + "StateOrProvince": "Test province", + "PostalCode": "12345", + "Country": "IT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.it" + }, + { + "lang": "en", + "uriValue": "tel:+39123456789" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.it" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/IT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_eudiw_solution_it" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICUDCCAfWgAwIBAgIUONlIPSqyFQVjT6+yy1zAFLS+fOUwCgYIKoZIzj0EAwIwfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMB4XDTI1MTEyMTE2MDcxOFoXDTM1MTExOTE2MDcxOFowfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsOCKDPMrqG3DKLHAEqkutBKCBHlSmuyeQGkLL95EW4oAzqVd+1aVPfXGNKSE6dgGb2wbrcqNz/wLyoTdBh3pkaNTMFEwHQYDVR0OBBYEFFdzfeaqb/ETC5YoB4Od5h4jVD7VMB8GA1UdIwQYMBaAFFdzfeaqb/ETC5YoB4Od5h4jVD7VMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSQAwRgIhAP8LhOOEB8HPNx0sobIBQgS3Ej1rtzXcx4hggAfyFFTJAiEAmJMJA1tgB/kl2gmH5TKH2R4QaWeHmgAZSFQcdZ7yEFM=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "ojeu:eudiw:ref_eudiw_solution_it" + } + ] + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Test street", + "Locality": "Test locality", + "StateOrProvince": "Test province", + "PostalCode": "123456", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36123456" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wallet_solution_ojeu_hu" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "ojeu:eudiw:ref_wallet_solution_hu" + } + ] + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Wallet Notification" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wallet@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+4235002211" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/information" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/PL" + } + ], + "TEInformationExtensions": [ + { + "OtherAssociatedBodies": [ + { + "AssociatedBodyName": [ + { + "lang": "en", + "value": "Wallet Notification Body" + } + ], + "AssociatedBodyTradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration Wallet Body" + }, + { + "lang": "en", + "value": "VATLI-3333" + } + ], + "AssociatedBodyAddress": { + "AssociatedBodyPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2A", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "AssociatedBodyElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wallet-body@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+42350022112" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/body" + } + ] + }, + "AssociatedBodyInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/body/information" + } + ] + } + ] + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "Wallet Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wallet/" + } + ], + "ServiceInformationExtensions": [ + { + "ServiceUniqueIdentifier": "REF:1234" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val wrpacProvidersFixed = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://uri.etsi.org/19602/LoTEType/EUWRPACProvidersList", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://uri.etsi.org/19602/WRPACProvidersList/StatusDetn/EU", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/WRPACProvidersList/schemerules/EU" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T09:21:34Z", + "NextUpdate": "2026-10-01T09:21:34Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse RP Access CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "1234", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.no" + }, + { + "lang": "en", + "uriValue": "tel:+47987654" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.no" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICuzCCAmGgAwIBAgIJAKcp7ByPxFNUMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNTA5MDc1NjU0WhcNMzAwNDI5MDc1NjU0WjBkMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxKjAoBgNVBAMTIWVpZGFzMnNhbmRrYXNzZSBSUCBBY2Nlc3MgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4OQr5vpRMvcYZs46LkpdDgVQ9V+9E/Gx3Io2jqm+g/43/0b2Ns9oSRv1VpY/vYSI/O6JWylRQ+MNk6V3DfQv2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUUcgCJYAwgpE7JCLUm9xeoainXcwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDSAAwRQIgfuk68h7gRHYXzBuddxFEUGl1eYtQgMCMKcw6D1kVjzgCIQC91xg+yGdocsoPmIGACivfYZAftiQXGEjHdid9RZOX1g==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Idakto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-12345" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "1234", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+33234567" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_fr" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICgjCCAiegAwIBAgIUafRAIleaQOm9jZLiIML9FeOWd9cwCgYIKoZIzj0EAwIwczELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZSQU5DRTEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJZGFrdG8xDjAMBgNVBAsMBVN0ZWFtMSEwHwYDVQQDDBhyZWFkZXItaXNzdWVyQGlkYWt0by5jb20wHhcNMjUwNzI1MTQ0NzI1WhcNMzAwNzI0MTQ0NzI1WjBzMQswCQYDVQQGEwJGUjEPMA0GA1UECAwGRlJBTkNFMQ8wDQYDVQQHDAZBbmdlcnMxDzANBgNVBAoMBklkYWt0bzEOMAwGA1UECwwFU3RlYW0xITAfBgNVBAMMGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCq6dkUsfqjCByvS+UM/FDOgjO5fbB6aEesAgWmiMrSJQybQnAGSOySr0V+E0puM3eMaLy4DzsGLW0LX6J+vRLOjgZgwgZUwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJ57lkHy09w59xHQDk4y9ubmup5VMCsGA1UdEQQkMCKCIG9wZW5pZDR2cC5kcnVrcXMuYXNnYXJkLmlkZW52LmZyMCMGA1UdEgQcMBqBGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9hIBNw8GI7E5z/NZI/3CUMZjndoKGg+2o0lh8/6gY30CIQCiUgMnIib46Ypi4IryQOn282zPWrTWQFwIebwASeG9+w==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36567890" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_hu" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-45678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "2345", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+43789012" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_wrpac_solution_at" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICJzCCAc6gAwIBAgIUSvMftn/oM3etHjE7hdIBl6tWMV8wCgYIKoZIzj0EAwIwMzELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMRQwEgYDVQQDDAtWYWxlcmEgSUFDQTAeFw0yNTA2MjYwODI0MDJaFw0yNjA2MjYwODI0MDJaMDMxCzAJBgNVBAYTAkFUMQ4wDAYDVQQKDAVBLVNJVDEUMBIGA1UEAwwLVmFsZXJhIElBQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQmm+pmyUxx/x2eD131E8HhvNkhsfYQXzefZlxgLXQPqCOxO+VPOXVOKL0dUy+kHyT5IP/NOAh038coAVOgGPT4o4G/MIG8MBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMCIGA1UdEgQbMBmGF2h0dHBzOi8vd2FsbGV0LmEtc2l0LmF0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHBzOi8vd2FsbGV0LmEtc2l0LmF0L2NybC8xLmNybDAfBgNVHSMEGDAWgBSDGoj0XuXE3qEVTmPvKSvIvR36ijAdBgNVHQ4EFgQUgxqI9F7lxN6hFU5j7ykryL0d+oowCgYIKoZIzj0EAwIDRwAwRAIgS9XcYA4Be5gDIdHmMOgJ3AeS44gT4bgVgsg/D5+WXS8CIAxJgi3nhGrVMj9SszehLorR2rR5FO5RZgITAaOIGSNP" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "WRPAC Provider - failing conformance checks" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "WRPAC Provider1" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-wrpac@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+423887744" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/information" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "WRPAC Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/wrpac/service/information" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + val mdlProvidersFixed = """ + { + "ListAndSchemeInformation": { + "LoTEVersionIdentifier": 1, + "LoTESequenceNumber": 2, + "LoTEType": "http://trust.ec.europa.eu/lists/mDL/mDLProvidersListType", + "SchemeOperatorName": [ + { + "lang": "en", + "value": "European Commission" + }, + { + "lang": "bg", + "value": "Европейска комисия" + }, + { + "lang": "es", + "value": "Comisión Europea" + }, + { + "lang": "cs", + "value": "Evropská komise" + }, + { + "lang": "da", + "value": "Europa-Kommissionen" + }, + { + "lang": "de", + "value": "Europäische Kommission" + }, + { + "lang": "et", + "value": "Euroopa Komisjon" + }, + { + "lang": "el", + "value": "Ευρωπαϊκή Επιτροπή" + }, + { + "lang": "fr", + "value": "Commission européenne" + }, + { + "lang": "it", + "value": "Commissione europea" + }, + { + "lang": "lv", + "value": "Eiropas Komisija" + }, + { + "lang": "lt", + "value": "Europos Komisija" + }, + { + "lang": "hu", + "value": "Európai Bizottság" + }, + { + "lang": "mt", + "value": "Il-Kummissjoni Ewropea" + }, + { + "lang": "nl", + "value": "Europese Commissie" + }, + { + "lang": "pl", + "value": "Komisja Europejska" + }, + { + "lang": "pt", + "value": "Comissão Europeia" + }, + { + "lang": "ro", + "value": "Comisia Europeană" + }, + { + "lang": "sk", + "value": "Európska komisia" + }, + { + "lang": "sl", + "value": "Evropska komisija" + }, + { + "lang": "fi", + "value": "Euroopan komissio" + }, + { + "lang": "sv", + "value": "Europeiska kommissionen" + }, + { + "lang": "hr", + "value": "Europska komisija" + } + ], + "SchemeOperatorAddress": { + "SchemeOperatorPostalAddress": [ + { + "lang": "fr", + "StreetAddress": "Rue de la Loi 200", + "Locality": "Bruxelles", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "nl", + "StreetAddress": "Wetstraat 200", + "Locality": "Brussel", + "PostalCode": "1049", + "Country": "BE" + }, + { + "lang": "en", + "StreetAddress": "Rue de la Loi/Wetstraat 200", + "Locality": "Brussels", + "PostalCode": "1049", + "Country": "BE" + } + ], + "SchemeOperatorElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu" + }, + { + "lang": "en", + "uriValue": "https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists" + } + ] + }, + "SchemeName": [ + { + "lang": "en", + "value": "The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980" + } + ], + "SchemeInformationURI": [ + { + "lang": "en", + "uriValue": "https://trust.tech.ec.europa.eu/lists/eudiw/mdl-providers-list-scheme-information" + } + ], + "StatusDeterminationApproach": "http://trust.ec.europa.eu/lists/mDL/mDLProvidersListStatusDetn", + "SchemeTypeCommunityRules": [ + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/schemerules" + } + ], + "SchemeTerritory": "EU", + "PolicyOrLegalNotice": [ + { + "LoTEPolicy": { + "lang": "en", + "uriValue": "http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN" + } + } + ], + "ListIssueDateTime": "2026-04-02T11:24:30Z", + "NextUpdate": "2026-10-01T11:24:30Z" + }, + "TrustedEntitiesList": [ + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Agence Nationale des Titres Sécurisés" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-2356568" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3465", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fr" + }, + { + "lang": "en", + "uriValue": "tel:+337848346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fr" + }, + { + "lang": "en", + "uriValue": "http://uri.etsi.org/19602/ListOfTrustedEntities/mDLProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + }, + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fr_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I" + } + ] + }, + "ServiceTypeIdentifier": "http://uri.etsi.org/19602/SvcType/mDL/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - Bevisporten" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5788", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digitaliseringsdirektoratet - mDL-utsteder" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-NOFOR.991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "3478", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA==" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Digi- ja väestötietovirasto" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFI-8567" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "5685", + "Country": "FI" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.fi" + }, + { + "lang": "en", + "uriValue": "tel:+358348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.fi" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/FI" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_fi" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse mDL Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "4332", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+47348346754" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_3" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "eidas2sandkasse Pub EAA Provider CA test" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "NTRNO-991825827" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "test", + "Country": "NO" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@test.no" + }, + { + "lang": "en", + "uriValue": "tel:+4734869323" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "http://test.no" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mDL_solution_no_4" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "AMA - Agência para a Modernização Administrativa" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATPT-27373" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "PT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.pt" + }, + { + "lang": "en", + "uriValue": "tel:+35198765" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.pt" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/PT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_pt" + } + ], + "ServiceDigitalIdentity": { + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "A-SIT" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-37373" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23451", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+4398279" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_at_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "IDAKTO IACA 4" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATFR-73829" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "23343", + "Country": "FR" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test@domain.fr" + }, + { + "lang": "en", + "uriValue": "tel:+33857302" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.fr" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/FR" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_fr_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "ISO Root CA" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATAT-90021" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "63823", + "Country": "AT" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.at" + }, + { + "lang": "en", + "uriValue": "tel:+33848209" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_at_2" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Bundesdruckerei GmbH" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATDE-82718" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "638382", + "Country": "DE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.de" + }, + { + "lang": "en", + "uriValue": "tel:+4971501" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.at" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/DE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_de_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "Microsec Ltd." + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATHU-23584497" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "73824", + "Country": "HU" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.hu" + }, + { + "lang": "en", + "uriValue": "tel:+36019283" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.hu" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/HU" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_hu_1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "TEST Authority" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEE-373091" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53242", + "Country": "EE" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.ee" + }, + { + "lang": "en", + "uriValue": "tel:+372932394" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.ee" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/EE" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_ee" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "GRNET" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "VATEL-7283" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Rue test", + "Locality": "test", + "StateOrProvince": "test", + "PostalCode": "53242", + "Country": "EL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:test2@domain.el" + }, + { + "lang": "en", + "uriValue": "tel:+302932394" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://test.el" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/EL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "name_mdl_solution_el" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ==" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance" + } + } + ] + }, + { + "TrustedEntityInformation": { + "TEName": [ + { + "lang": "en", + "value": "mDL Provider1" + } + ], + "TETradeName": [ + { + "lang": "en", + "value": "Liechtenstein National Administration" + }, + { + "lang": "en", + "value": "VATLI-2345678" + } + ], + "TEAddress": { + "TEPostalAddress": [ + { + "lang": "en", + "StreetAddress": "Platz 2", + "Locality": "Vaduz", + "StateOrProvince": "Liechtenstein", + "PostalCode": "Fl-001", + "Country": "PL" + } + ], + "TEElectronicAddress": [ + { + "lang": "en", + "uriValue": "mailto:office-mdl@test.li" + }, + { + "lang": "en", + "uriValue": "tel:+423887744" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl" + } + ] + }, + "TEInformationURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/policies" + }, + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/information" + }, + { + "lang": "en", + "uriValue": "http://trust.ec.europa.eu/lists/mDL/mDLProvider/PL" + } + ] + }, + "TrustedEntityServices": [ + { + "ServiceInformation": { + "ServiceName": [ + { + "lang": "en", + "value": "mDL Service 1" + } + ], + "ServiceDigitalIdentity": { + "X509Certificates": [ + { + "val": "MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I=" + } + ] + }, + "ServiceTypeIdentifier": "http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance", + "ServiceSupplyPoints": [ + { + "uriValue": "http://supply.points", + "ServiceType": "http://supply.pointstype" + } + ], + "ServiceDefinitionURI": [ + { + "lang": "en", + "uriValue": "https://www.llv.li/en/mdl/service/information" + } + ] + } + } + ] + } + ] + } + """.trimIndent() + + + data class TestData( + val json: String, + val expectedServiceType: String + ) + + testSuite("filter lote by type identifier") { + withData( + nameFn = { it.first }, // Uses the key as the test name + "pidProviders" to TestData(pidProvidersFixed, "http://uri.etsi.org/19602/SvcType/PID/Issuance"), + "walletProviders" to TestData(walletProvidersFixed, "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance"), + "wrpacProviders" to TestData(wrpacProvidersFixed, "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"), + "mdlProviders" to TestData(mdlProvidersFixed, "http://uri.etsi.org/19602/SvcType/mDL/Issuance"), + ) { (_, data) -> + val lote = Json.decodeFromString(data.json) + + val criteria = LoTEFilterCriteria(expectedServiceType = data.expectedServiceType) + + val trustedCerts = LoTEFilterService().extractTrustedCertificates(lote, criteria) + + trustedCerts.size shouldNotBe(0) + } + } +} \ No newline at end of file diff --git a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt b/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt deleted file mode 100644 index aab1a39d2..000000000 --- a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/VerificationTest.kt +++ /dev/null @@ -1,16 +0,0 @@ -package at.asitplus.etsi - -import at.asitplus.etsi.verification.TrustListLoader -import de.infix.testBalloon.framework.core.testSuite -import io.matthewnelson.encoding.base64.Base64 - -val VerificationTest by testSuite { - - - test("test deserialization") { - val loader = TrustListLoader() - - val list = loader.fetchTrustList() - println(list) - } -} \ No newline at end of file diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt similarity index 98% rename from vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt rename to vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt index 2ce92c8a6..13c07800e 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/LoTEValidator.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt @@ -1,4 +1,4 @@ -package at.asitplus.etsi.verification +package at.asitplus.wallet.lib import at.asitplus.signum.indispensable.X509SignatureAlgorithm import at.asitplus.signum.indispensable.pki.CertificateChain From 30c515acbac00cb13ae65b0ad527754a67e9240a Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Fri, 22 May 2026 15:55:53 +0200 Subject: [PATCH 05/16] add trust list validation, implement tests # Conflicts: # vck/build.gradle.kts --- .../etsi/verification/TrustListLoader.kt | 90 --------- vck/build.gradle.kts | 1 + .../wallet/lib/etsi}/LoTEFilterService.kt | 2 +- .../lib/{ => etsi}/TrustListValidator.kt | 44 +++-- .../wallet/lib}/etsi/LoTEFilterTest.kt | 5 +- .../wallet/lib/etsi/TrustListValidatorTest.kt | 175 ++++++++++++++++++ 6 files changed, 204 insertions(+), 113 deletions(-) delete mode 100644 etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt rename {etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification => vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi}/LoTEFilterService.kt (98%) rename vck/src/commonMain/kotlin/at/asitplus/wallet/lib/{ => etsi}/TrustListValidator.kt (53%) rename {etsi-data-classes/src/commonTest/kotlin/at/asitplus => vck/src/jvmTest/kotlin/at/asitplus/wallet/lib}/etsi/LoTEFilterTest.kt (99%) create mode 100644 vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt deleted file mode 100644 index adcb5e98d..000000000 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/TrustListLoader.kt +++ /dev/null @@ -1,90 +0,0 @@ -package at.asitplus.etsi.verification - -import at.asitplus.etsi.ListOfTrustedEntities -import at.asitplus.signum.indispensable.josef.JwsSigned -import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer -import io.ktor.client.HttpClient -import io.ktor.client.call.body -import io.ktor.client.plugins.contentnegotiation.ContentNegotiation -import io.ktor.client.request.accept -import io.ktor.client.request.get -import io.ktor.client.statement.bodyAsText -import io.ktor.http.ContentType -import io.ktor.http.HttpStatusCode -import io.ktor.serialization.kotlinx.json.json -import io.ktor.utils.io.InternalAPI -import io.matthewnelson.encoding.base64.Base64 -import kotlinx.serialization.json.Json -import io.ktor.util.decodeBase64String -import kotlinx.serialization.SerialName -import kotlinx.serialization.Serializable -import kotlinx.serialization.builtins.serializer -import kotlinx.serialization.json.decodeFromJsonElement -import kotlinx.serialization.json.jsonObject - - -class TrustListLoader { - private val httpClient = HttpClient { - install(ContentNegotiation) { - json(joseCompliantSerializer) - } - } - - /** - * Fetches the Trust List across any target platform (iOS, Android, JVM, etc.) - */ - @OptIn(InternalAPI::class) - suspend fun fetchTrustList(): ListOfTrustedEntities? { - val url = "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" - - val response = httpClient.get(url) { - accept(ContentType.Application.Json) - } - - val jwsCompactString = response.body() - - // Deserialize the JWS directly. - // JwsSigned handles the Base64Url decoding and delegates JSON parsing to your jsonParser. - val jws = JwsSigned.deserialize( - TrustListJwsPayload.serializer(), - jwsCompactString, - joseCompliantSerializer - ).getOrThrow() - - // The deserialized data is available safely on the payload property - val ret = jws.payload.loTe - return ret -// val jwsCompactString = response.bodyAsText().trim('"', ' ', '\n', '\r') -// -// val parts = jwsCompactString.split(".") -// require(parts.size == 3) { -// "The response is not a valid JWS token format. Got ${parts.size} parts." -// } -// -// // 3. Extract and fix the missing Base64 padding on the payload -// var base64Payload = parts[1] -// .replace('-', '+') -// .replace('_', '/') -// -// // 4. Decode directly to a String using Ktor's KMP utility -// val decodedJsonPayload = base64Payload.decodeBase64String() -// -// // 5. Deserialize using the class-level jsonParser -// val rootElement = jsonParser.parseToJsonElement(decodedJsonPayload) -// -// // 6. Extract the "LoTE" object from the root -// val loTeElement = rootElement.jsonObject["LoTE"] -// ?: throw IllegalArgumentException("The decoded JSON does not contain the 'LoTE' key.") -// -// // 7. Deserialize ONLY the inner object into your class -// val ret = jsonParser.decodeFromJsonElement(loTeElement) -// return ret - } -} - -@Serializable -data class TrustListJwsPayload( - @SerialName("LoTE") - val loTe: ListOfTrustedEntities -) - diff --git a/vck/build.gradle.kts b/vck/build.gradle.kts index e9d764066..eac74f9e6 100644 --- a/vck/build.gradle.kts +++ b/vck/build.gradle.kts @@ -29,6 +29,7 @@ kotlin { dependencies { api(project(":dif-data-classes")) api(project(":openid-data-classes")) + api(project(":etsi-data-classes")) api(project(":sd-jwt-type-metadata")) commonImplementationAndApiDependencies() } diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt similarity index 98% rename from etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt rename to vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt index d41005b8a..d5c8b2db0 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/verification/LoTEFilterService.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt @@ -1,4 +1,4 @@ -package at.asitplus.etsi.verification +package at.asitplus.wallet.lib.etsi import at.asitplus.etsi.EtsiX509CertificateSerializer import at.asitplus.etsi.ListOfTrustedEntities diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt similarity index 53% rename from vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt rename to vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt index 13c07800e..6ebb5b8d9 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/TrustListValidator.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt @@ -1,29 +1,34 @@ -package at.asitplus.wallet.lib +package at.asitplus.wallet.lib.etsi +import at.asitplus.KmmResult +import at.asitplus.catching import at.asitplus.signum.indispensable.X509SignatureAlgorithm import at.asitplus.signum.indispensable.pki.CertificateChain import at.asitplus.signum.indispensable.pki.X509Certificate -import at.asitplus.signum.indispensable.requireSupported import at.asitplus.signum.supreme.sign.verifierFor import at.asitplus.signum.supreme.sign.verify import kotlin.time.Clock import kotlin.time.Instant /** - * Verifies if this leaf certificate is directly signed and trusted by any anchor in the [trustStore]. - * Enforces strict timeliness, cryptographic integrity, and anchor constraints. + * Verifies if this certificate is directly signed and trusted by any anchor in the [trustStore]. + * Enforces strict timeliness, cryptographic integrity */ fun X509Certificate.isDirectlyTrustedBy( trustStore: CertificateChain, date: Instant = Clock.System.now() -): Boolean { - if (!this.isValidAt(date)) return false - - return trustStore - .filter { anchor -> anchor.tbsCertificate.subjectName == this.tbsCertificate.issuerName } - .any { anchor -> - anchor.isValidAt(date) && anchor.isIssuerOf(this) - } +): KmmResult = catching { + if (!this.isValidAt(date)) throw Exception("Certificate is not valid at $date") + + trustStore + .asSequence() + .filter { it.isValidAt(date) } + .map { it.isIssuerOf(this) } + .firstOrNull { it.isSuccess } + ?: throw IllegalArgumentException( + "No valid trust anchor could verify certificate" + ) + } /** @@ -48,13 +53,14 @@ fun X509Certificate.isNotYetValid(date: Instant = Clock.System.now()): Boolean = */ fun X509Certificate.isValidAt(date: Instant = Clock.System.now()): Boolean = !(isExpired(date) || isNotYetValid(date)) -fun X509Certificate.isIssuerOf(cert: X509Certificate): Boolean { - val verifier = (cert.signatureAlgorithm.requireSupported() as X509SignatureAlgorithm).verifierFor(this.decodedPublicKey.getOrThrow()).getOrElse { return false } - val signatureValid = verifier.verify( +fun X509Certificate.isIssuerOf(cert: X509Certificate): KmmResult = catching { + if (cert.tbsCertificate.issuerName != this.tbsCertificate.subjectName) throw Exception("Subject of issuer cert and issuer of child certificate mismatch.") + + if (cert.tbsCertificate.issuerUniqueID != this.tbsCertificate.subjectUniqueID) throw Exception("UID of issuer cert and UID of issuer in child certificate mismatch.") + + val verifier = (cert.signatureAlgorithm as X509SignatureAlgorithm).verifierFor(this.decodedPublicKey.getOrThrow()).getOrThrow() + verifier.verify( cert.tbsCertificate.encodeToDer(), cert.decodedSignature.getOrThrow() - ).isSuccess - - val issuerName = cert.tbsCertificate.issuerName - return signatureValid && issuerName == this.tbsCertificate.subjectName + ).getOrThrow() } \ No newline at end of file diff --git a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt similarity index 99% rename from etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt rename to vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt index 29c3174a4..980346eb8 100644 --- a/etsi-data-classes/src/commonTest/kotlin/at/asitplus/etsi/LoTEFilterTest.kt +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt @@ -1,7 +1,6 @@ -package at.asitplus.etsi +package at.asitplus.wallet.lib.etsi -import at.asitplus.etsi.verification.LoTEFilterCriteria -import at.asitplus.etsi.verification.LoTEFilterService +import at.asitplus.etsi.ListOfTrustedEntities import at.asitplus.testballoon.withData import de.infix.testBalloon.framework.core.testSuite import io.kotest.matchers.shouldNotBe diff --git a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt new file mode 100644 index 000000000..f97b49e7f --- /dev/null +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt @@ -0,0 +1,175 @@ +package at.asitplus.wallet.lib.etsi + +import at.asitplus.signum.indispensable.pki.X509Certificate +import de.infix.testBalloon.framework.core.testSuite +import io.kotest.matchers.shouldBe +import at.asitplus.testballoon.invoke + + +val TrustListValidatorTest by testSuite { + + val trustAnchorPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDRzCCAi+gAwIBAgIBATANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMVHJ1c3Qg\n" + + "QW5jaG9yMB4XDTEwMDEwMTA4MzAwMFoXDTMwMTIzMTA4MzAwMFowRTELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExFTATBgNVBAMT\n" + + "DFRydXN0IEFuY2hvcjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALmZ\n" + + "UYkRR+DNRbmEJ4ITAhbNRDmqrNsJw97iLE7bpFeflDUoNcJrZPZbC208bG+g5M0A\n" + + "TzV0vOqg88Ds1/FjFDK1oPItqsiDImJIq0xb/et5w72WNPxHVrcsr7Ap6DHfdwLp\n" + + "NMncqtzX92hU/iGVHLE/w/OCWwAIIbTHaxdrGMUG7DkJJ6iI7mzqpcyPvyAAo9O3\n" + + "SHjJr+uw5vSrHRretnV2un0bohvGslN64MY/UIiRnPFwd2gD76byDzoM1ioyLRCl\n" + + "lfBJ5sRDz9xrUHNigTAUdlblb6yrnNtNJmkrROYvkh6sLETUh9EYh0Ar+94fZVXf\n" + + "GVi57Sw7x1jyANTlA40CAwEAAaNCMEAwHQYDVR0OBBYEFOR9X9FclYYILAWuvnW2\n" + + "ZafZXahmMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3\n" + + "DQEBCwUAA4IBAQCYoa9uR55KJTkpwyPihIgXHq7/Z8dx3qZlCJQwE5qQBZXIsf5e\n" + + "C8Va/QjnTHOC4Gt4MwpnqqmoDqyqSW8pBVQgAUFAXqO91nLCQb4+/yfjiiNjzprp\n" + + "xQlcqIZYjJSVtckH1IDWFLFeuGW+OgPPEFgN4hjU5YFIsE2r1i4+ixkeuorxxsK1\n" + + "D/jYbVwQMXLqn1pjJttOPJwuA8+ho1f2c8FrKlqjHgOwxuHhsiGN6MKgs1baalpR\n" + + "/lnNFCIpq+/+3cnhufDjvxMy5lg+cwgMCiGzCxn4n4dBMw41C+4KhNF7ZtKuKSZ1\n" + + "eczztXD9NUkGUGw3LzpLDJazz3JhlZ/9pXzF\n" + + "-----END CERTIFICATE-----" + + "valid signature" { + val testCertPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDfDCCAmSgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMVHJ1c3Qg\n" + + "QW5jaG9yMB4XDTEwMDEwMTA4MzAwMFoXDTMwMTIzMTA4MzAwMFowQDELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExEDAOBgNVBAMT\n" + + "B0dvb2QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCQWJpHYo37\n" + + "Xfb7oJSPe+WvfTlzIG21WQ7MyMbGtK/m8mejCzR6c+f/pJhEH/OcDSMsXq8h5kXa\n" + + "BGqWK+vSwD/Pzp5OYGptXmGPcthDtAwlrafkGOS4GqIJ8+k9XGKs+vQUXJKsOk47\n" + + "RuzD6PZupq4s16xaLVqYbUC26UcY08GpnoLNHJZS/EmXw1ZZ3d4YZjNlpIpWFNHn\n" + + "UGmdiGKXUPX/9H0fVjIAaQwjnGAbpgyCumWgzIwPpX+ElFOUr3z7BoVnFKhIXze+\n" + + "VmQGSWxZxvWDUN90Ul0tLEpLgk3OVxUB4VUGuf15OJOpgo1xibINPmWt14Vda2N9\n" + + "yrNKloJGZNqLAgMBAAGjfDB6MB8GA1UdIwQYMBaAFOR9X9FclYYILAWuvnW2ZafZ\n" + + "XahmMB0GA1UdDgQWBBRYAYQkG7wrUpRKPaUQchRR9a86yTAOBgNVHQ8BAf8EBAMC\n" + + "AQYwFwYDVR0gBBAwDjAMBgpghkgBZQMCATABMA8GA1UdEwEB/wQFMAMBAf8wDQYJ\n" + + "KoZIhvcNAQELBQADggEBADWHlxbmdTXNwBL/llwhQqwnazK7CC2WsXBBqgNPWj7m\n" + + "tvQ+aLG8/50Qc2Sun7o2VnwF9D18UUe8Gj3uPUYH+oSI1vDdyKcjmMbKRU4rk0eo\n" + + "3UHNDXwqIVc9CQS9smyV+x1HCwL4TTrq+LXLKx/qVij0Yqk+UJfAtrg2jnYKXsCu\n" + + "FMBQQnWCGrwa1g1TphRp/RmYHnMynYFmZrXtzFz+U9XEA7C+gPq4kqDI/iVfIT1s\n" + + "6lBtdB50lrDVwl2oYfAvW/6sC2se2QleZidUmrziVNP4oEeXINokU6T6p//HM1FG\n" + + "QYw2jOvpKcKtWCSAnegEbgsGYzATKjmPJPJ0npHFqzM=\n" + + "-----END CERTIFICATE-----\n" + + val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) + val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() + + leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe true + } + + "invalid signature" { + val testCertPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDgjCCAmqgAwIBAgIBAzANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMVHJ1c3Qg\n" + + "QW5jaG9yMB4XDTEwMDEwMTA4MzAwMFoXDTMwMTIzMTA4MzAwMFowRjELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExFjAUBgNVBAMT\n" + + "DUJhZCBTaWduZWQgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDf\n" + + "77zrq/d3vnq9i8r8Trn+BmzL4FkkTxewQRXNUnk6QnZ3Zi929sKAyv6cHCJK0r3p\n" + + "JQj89gjkcHFt4Wsqzo9cRS/39ynAiCBoPqdOdCiy6J1AhKjMAVjrx0U597QUMKXj\n" + + "jQvxpsLptqnn6kEX0VQzHqrChCbYogCHGVzyOEM8EA4KK8byAf2ZwUE34FqcSYjb\n" + + "XtX2Kl+NsNGEBMTiqNEE82w+HmuRM5XYxG9+3EnCuT5O5b4WWqzsvYHAXEzgu+K0\n" + + "ghe4Wail7rFP1Ho046GZCwUzi+U518bek8liQ9qiqS1L6oVa8dnQf7QDImDBIb5F\n" + + "+2IJmU/NPAJwTNAhK3mBAgMBAAGjfDB6MB8GA1UdIwQYMBaAFOR9X9FclYYILAWu\n" + + "vnW2ZafZXahmMB0GA1UdDgQWBBR73RA7SuDI3USFTog8WovNmSKTrzAOBgNVHQ8B\n" + + "Af8EBAMCAQYwFwYDVR0gBBAwDjAMBgpghkgBZQMCATABMA8GA1UdEwEB/wQFMAMB\n" + + "Af8wDQYJKoZIhvcNAQELBQADggEBAWS/T/8EU0O0tLjvTs5hWudZV+co6/NMpRBk\n" + + "gUjCI8VuNjpi/bmhLuNioJ3tCgLWlZ4Lhd9fLyOvktEo5HtJ0HNedz1Nq6+L4S+u\n" + + "h8yYAIXSawnnyZLof8p67U4Z0hz7typr+a9FLpbkvOi6KUykbEgNOwES0+2PZLlf\n" + + "0O3/I4JLkA7w0JXQi6CyOgVlRxF6fxw4O3Z/C+u560TndrUaISdyugt9a00gTmZc\n" + + "9cQpAfZUn6WS0xp4D+xQ1h1l8BU0nXR32uODwxTh4PHh6sjZhY4pWrwbRgBjKkzI\n" + + "iqEDzQlzqYwtPjIntlbAkwC4KM1pFaMwZU+WJ79rrPJGMGWFF3Y=\n" + + "-----END CERTIFICATE-----\n" + + val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) + val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() + + leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe false + } + + "Invalid notBefore date" { + val testCertPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDijCCAnKgAwIBAgIBBDANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMVHJ1c3Qg\n" + + "QW5jaG9yMB4XDTQ3MDEwMTEyMDEwMFoXDTQ5MDEwMTEyMDEwMFowTjELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExHjAcBgNVBAMT\n" + + "FUJhZCBub3RCZWZvcmUgRGF0ZSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC\n" + + "AQoCggEBAKdTl1qhx5hGD+CvPHQU/pDSJCVnLWeXmdblHoJ746b/bW3/GkXFSUPl\n" + + "1yT36yl6CZJzUJqOYzFkSE3aN2vDcrjviJOAInET39JOxLTkc7J8DxCpz13PmliN\n" + + "KpQl5p3fY3Lll8UumG/5mZsdphQSp2gIN6w68nJKS6Nmad46or/5l1qsAteEjIGx\n" + + "a26CC6tV5yEqchk1Htsd4hJz7xUi7vijBM987pOidUjCYNltpZYQYvdbGIjl2LnX\n" + + "ILVLy2B7Sska+bMVllQM6d932/mzFUxCXCR7eow5ZKo3dPAKOuwTnjTAR3MHfCij\n" + + "/mRVgxSBDh017j55dVB16y0Si9flCfkCAwEAAaN8MHowHwYDVR0jBBgwFoAU5H1f\n" + + "0VyVhggsBa6+dbZlp9ldqGYwHQYDVR0OBBYEFGM+vBqe+6HyWaEvS5X+5t5WuIZA\n" + + "MA4GA1UdDwEB/wQEAwIBBjAXBgNVHSAEEDAOMAwGCmCGSAFlAwIBMAEwDwYDVR0T\n" + + "AQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAtkgaLAbOwuudAqkh/5xJw8ur\n" + + "RsA3e1joOqVXy3iP5Uj8o663gzdoBl+sIyDGntdx0h5GjR4QM/SWPlz5yxFrExe/\n" + + "AaoxXHr77fYZfkgGBCLblxo3wb0iNpKz5OKmb4qtwEOpHygOpSSiV5e2wZDjhN1q\n" + + "yR3v2lR5L2exD+k4l2Td/0w4uCpom62k+sWY36/h/zKiWFWhnIWqpHYyYOGhYzTM\n" + + "EtJNWj6H0EWEoB1YNsNZYT3f2w4jOFa7oxfiqFS9kzXIjenc+MIt9uU6+oLFjdzt\n" + + "jVCxa181mRD3+OiQw9SDtTZXEwPQmp0jj7B5bLGSKK477cAIX1uqxE7jyO8t2g==\n" + + "-----END CERTIFICATE-----\n" + + val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) + val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() + + leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe false + } + + "invalid name chaining" { + val taPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDfDCCAmSgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMVHJ1c3Qg\n" + + "QW5jaG9yMB4XDTEwMDEwMTA4MzAwMFoXDTMwMTIzMTA4MzAwMFowQDELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExEDAOBgNVBAMT\n" + + "B0dvb2QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCQWJpHYo37\n" + + "Xfb7oJSPe+WvfTlzIG21WQ7MyMbGtK/m8mejCzR6c+f/pJhEH/OcDSMsXq8h5kXa\n" + + "BGqWK+vSwD/Pzp5OYGptXmGPcthDtAwlrafkGOS4GqIJ8+k9XGKs+vQUXJKsOk47\n" + + "RuzD6PZupq4s16xaLVqYbUC26UcY08GpnoLNHJZS/EmXw1ZZ3d4YZjNlpIpWFNHn\n" + + "UGmdiGKXUPX/9H0fVjIAaQwjnGAbpgyCumWgzIwPpX+ElFOUr3z7BoVnFKhIXze+\n" + + "VmQGSWxZxvWDUN90Ul0tLEpLgk3OVxUB4VUGuf15OJOpgo1xibINPmWt14Vda2N9\n" + + "yrNKloJGZNqLAgMBAAGjfDB6MB8GA1UdIwQYMBaAFOR9X9FclYYILAWuvnW2ZafZ\n" + + "XahmMB0GA1UdDgQWBBRYAYQkG7wrUpRKPaUQchRR9a86yTAOBgNVHQ8BAf8EBAMC\n" + + "AQYwFwYDVR0gBBAwDjAMBgpghkgBZQMCATABMA8GA1UdEwEB/wQFMAMBAf8wDQYJ\n" + + "KoZIhvcNAQELBQADggEBADWHlxbmdTXNwBL/llwhQqwnazK7CC2WsXBBqgNPWj7m\n" + + "tvQ+aLG8/50Qc2Sun7o2VnwF9D18UUe8Gj3uPUYH+oSI1vDdyKcjmMbKRU4rk0eo\n" + + "3UHNDXwqIVc9CQS9smyV+x1HCwL4TTrq+LXLKx/qVij0Yqk+UJfAtrg2jnYKXsCu\n" + + "FMBQQnWCGrwa1g1TphRp/RmYHnMynYFmZrXtzFz+U9XEA7C+gPq4kqDI/iVfIT1s\n" + + "6lBtdB50lrDVwl2oYfAvW/6sC2se2QleZidUmrziVNP4oEeXINokU6T6p//HM1FG\n" + + "QYw2jOvpKcKtWCSAnegEbgsGYzATKjmPJPJ0npHFqzM=\n" + + "-----END CERTIFICATE-----" + + val testCertPem = "-----BEGIN CERTIFICATE-----\n" + + "MIIDjjCCAnagAwIBAgIBCTANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + + "MB0GA1UEChMWVGVzdCBDZXJ0aWZpY2F0ZXMgMjAxMTEVMBMGA1UEAxMMR29vZCBD\n" + + "QSBSb290MB4XDTEwMDEwMTA4MzAwMFoXDTMwMTIzMTA4MzAwMFowYzELMAkGA1UE\n" + + "BhMCVVMxHzAdBgNVBAoTFlRlc3QgQ2VydGlmaWNhdGVzIDIwMTExMzAxBgNVBAMT\n" + + "KkludmFsaWQgTmFtZSBDaGFpbmluZyBFRSBDZXJ0aWZpY2F0ZSBUZXN0MTCCASIw\n" + + "DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL+nEW5gQmCvT4PQ4bfEwb8YmHX2\n" + + "bhQjlGRTHO894s1c8ntn8sOGipmZujpyWKEnuLYYXnrx/8d6EaQ5iHWc2STa5xO2\n" + + "/FYakp8YF7+wGIrvAKI2gXIaIFzFC6BBtZiDBb9esrLPA3tiu6u5F9WBsGWuA1TQ\n" + + "jKqaTll9i5WvnXY8Fq4JbfHOeh9SCJKnyLtY/o6QqfJu4IvGIy3SVMUOpy35ZR6O\n" + + "Hdy4JXBISnOe44NDd27PQNnkb7VlcvspL873wQSp5YJKW5tvoPMtCGegEssZIGGN\n" + + "lN9bNTzeXAB+BfwtYoqP0Ej769uC6863UgGeWztLxe5YlvyS7CXaMmNdyosCAwEA\n" + + "AaNrMGkwHwYDVR0jBBgwFoAUWAGEJBu8K1KUSj2lEHIUUfWvOskwHQYDVR0OBBYE\n" + + "FBrADjt6tfm3fhTgKkOCvTN+XnXkMA4GA1UdDwEB/wQEAwIE8DAXBgNVHSAEEDAO\n" + + "MAwGCmCGSAFlAwIBMAEwDQYJKoZIhvcNAQELBQADggEBAHmYLicHjD0aYoBwgy4J\n" + + "fY9KHQVyP3enwjKFrzxt3lLh0+hvUeJG49oxt3lRPjU5d7GJYSzB9hmbECnD8hYf\n" + + "/NVRIa6UnLTK/blp3yc0fgYrZSFgzU77f6i51hxScIwprI/rNKUKjwYwPBQ6XZoS\n" + + "Lb5nZkbFoSaPjorD7/rTBp1A0vPt9QNn8wBph59HSKyUnHm256Y5kv67Knkt5W11\n" + + "tazp3HAc2nsE21MClKg4S4IHQYCva6p3KhViH5Wntu0AaG6Cl3eVbMDe+rzu2i7a\n" + + "SsP+m1IhK/geXvUOHGkKQd0ESsNaHakpy5mQXpYbxxpem1NCcsbPPlipMa0AN5p/\n" + + "ksU=\n" + + "-----END CERTIFICATE-----" + + val trustList = listOf( + X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow(), + X509Certificate.decodeFromPem(taPem).getOrThrow() + ) + val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() + + val result = leaf.isDirectlyTrustedBy(trustList) + result.isSuccess shouldBe false + result.exceptionOrNull()?.message shouldBe "No valid trust anchor could verify certificate" + } +} \ No newline at end of file From c9906b46c3e89910e6f423e5fd5cfc0a77f96c7d Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 26 May 2026 11:48:01 +0200 Subject: [PATCH 06/16] polishing --- .../at/asitplus/wallet/lib/etsi/LoTEFilterService.kt | 2 +- .../at/asitplus/wallet/lib/etsi/TrustListValidator.kt | 5 ++++- .../kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt | 2 +- .../at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt | 8 ++++---- 4 files changed, 10 insertions(+), 7 deletions(-) diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt index d5c8b2db0..868e87ef6 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterService.kt @@ -20,7 +20,7 @@ class LoTEFilterService { entity.trustedEntityServices .filter { it.serviceInformation.serviceTypeIdentifier?.string == criteria.expectedServiceType } .flatMap { service -> service.serviceInformation.serviceDigitalIdentity.x509Certificates } -// .filter { cert -> cert?.hasMatchingOrganization(providerName) == true } + .filter { cert -> cert?.hasMatchingOrganization(providerName) == true } .map { cert -> TrustedCertificate(cert, providerName, criteria.expectedServiceType) } } } diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt index 6ebb5b8d9..71383246b 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt @@ -14,7 +14,7 @@ import kotlin.time.Instant * Verifies if this certificate is directly signed and trusted by any anchor in the [trustStore]. * Enforces strict timeliness, cryptographic integrity */ -fun X509Certificate.isDirectlyTrustedBy( +fun X509Certificate.isTrustedBy( trustStore: CertificateChain, date: Instant = Clock.System.now() ): KmmResult = catching { @@ -53,6 +53,9 @@ fun X509Certificate.isNotYetValid(date: Instant = Clock.System.now()): Boolean = */ fun X509Certificate.isValidAt(date: Instant = Clock.System.now()): Boolean = !(isExpired(date) || isNotYetValid(date)) +/** + * Verifies that this certificate is the issuer of the given [cert]. + */ fun X509Certificate.isIssuerOf(cert: X509Certificate): KmmResult = catching { if (cert.tbsCertificate.issuerName != this.tbsCertificate.subjectName) throw Exception("Subject of issuer cert and issuer of child certificate mismatch.") diff --git a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt index 980346eb8..eb6a5cb1f 100644 --- a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt @@ -6,7 +6,7 @@ import de.infix.testBalloon.framework.core.testSuite import io.kotest.matchers.shouldNotBe import kotlinx.serialization.json.Json -val VerificationTest by testSuite { +val LoTEFilterTest by testSuite { val pidProvidersOriginal = """ { diff --git a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt index f97b49e7f..410269bba 100644 --- a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt @@ -55,7 +55,7 @@ val TrustListValidatorTest by testSuite { val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() - leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe true + leaf.isTrustedBy(trustList).isSuccess shouldBe true } "invalid signature" { @@ -84,7 +84,7 @@ val TrustListValidatorTest by testSuite { val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() - leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe false + leaf.isTrustedBy(trustList).isSuccess shouldBe false } "Invalid notBefore date" { @@ -113,7 +113,7 @@ val TrustListValidatorTest by testSuite { val trustList = listOf(X509Certificate.decodeFromPem(trustAnchorPem).getOrThrow()) val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() - leaf.isDirectlyTrustedBy(trustList).isSuccess shouldBe false + leaf.isTrustedBy(trustList).isSuccess shouldBe false } "invalid name chaining" { @@ -168,7 +168,7 @@ val TrustListValidatorTest by testSuite { ) val leaf = X509Certificate.decodeFromPem(testCertPem).getOrThrow() - val result = leaf.isDirectlyTrustedBy(trustList) + val result = leaf.isTrustedBy(trustList) result.isSuccess shouldBe false result.exceptionOrNull()?.message shouldBe "No valid trust anchor could verify certificate" } From ab7f52501f175e079a5395f9c7f17b2be23e3226 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 26 May 2026 12:12:33 +0200 Subject: [PATCH 07/16] update changelog # Conflicts: # CHANGELOG.md # Conflicts: # CHANGELOG.md --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1571e43f2..d086dc7ee 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -50,6 +50,8 @@ Release 6.0.0 (unreleased): - Update Bouncy Castle 1.84 - Update to kotlinx.coroutines 1.11.0 - Matrix testing + - Add `LoTEFilterService` for extracting trust list certificates from `LoTE` based on `ServiceTypeIdentifier` + - Add signature and time validity checks of certificate against the trust list Release 5.12.0: - W3C JWT VC: From d1de9f4d4e4a508722065a223e215f3ae9213a5f Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 26 May 2026 12:27:46 +0200 Subject: [PATCH 08/16] align ServiceDigitalIdentity requirements to aligh with specification --- .../kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt index cbfad313c..98a336848 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/ServiceDigitalIdentity.kt @@ -33,18 +33,15 @@ data class ServiceDigitalIdentity( val otherIds: List? = null, ) { init { -// require(x509Certificates?.isNotEmpty() != false) { -// "Expected at least 1 X509Certificate, but got 0." -// } + require( x509Certificates.isNotEmpty() || x509SKIs?.isNotEmpty() != false) { + "Expected at least 1 X509Certificate or at least 1 X509SKI, but got 0." + } require(x509SubjectNames?.isNotEmpty() != false) { "Expected at least 1 X509SubjectName, but got 0." } require(publicKeyValues?.isNotEmpty() != false) { "Expected at least 1 PublicKeyValue, but got 0." } - require(x509SKIs?.isNotEmpty() != false) { - "Expected at least 1 X509SKI, but got 0." - } require(otherIds?.isNotEmpty() != false) { "Expected at least 1 other id, but got 0." } From ded42218795e17a066c3ab86df1eb7c68f90e35f Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Mon, 1 Jun 2026 17:09:05 +0200 Subject: [PATCH 09/16] add LoTE jws (JAdES B-B) validation --- .../wallet/lib/etsi/TrustListValidator.kt | 4 +- .../at/asitplus/wallet/lib/jws/JwsService.kt | 62 +++++++++ .../asitplus/wallet/lib/jws/JwsServiceTest.kt | 131 +++++++++++++++++- 3 files changed, 193 insertions(+), 4 deletions(-) diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt index 71383246b..56e7df2d2 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidator.kt @@ -12,7 +12,7 @@ import kotlin.time.Instant /** * Verifies if this certificate is directly signed and trusted by any anchor in the [trustStore]. - * Enforces strict timeliness, cryptographic integrity + * Enforces time validity, cryptographic integrity */ fun X509Certificate.isTrustedBy( trustStore: CertificateChain, @@ -33,7 +33,6 @@ fun X509Certificate.isTrustedBy( /** * Checks whether this certificate has expired at the specified [date]. - * * @return `true` if the certificate is expired, `false` otherwise. */ fun X509Certificate.isExpired(date: Instant = Clock.System.now()): Boolean = @@ -41,7 +40,6 @@ fun X509Certificate.isExpired(date: Instant = Clock.System.now()): Boolean = /** * Checks whether this certificate is not yet valid at the specified [date]. - * * @return `true` if the certificate is not yet valid, `false` otherwise. */ fun X509Certificate.isNotYetValid(date: Instant = Clock.System.now()): Boolean = diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt index d517cef66..c7097e4ac 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt @@ -6,6 +6,7 @@ import at.asitplus.signum.indispensable.CryptoPublicKey import at.asitplus.signum.indispensable.Digest import at.asitplus.signum.indispensable.KeyAgreementPrivateValue import at.asitplus.signum.indispensable.asn1.encoding.encodeTo4Bytes +import at.asitplus.signum.indispensable.io.Base64UrlStrict import at.asitplus.signum.indispensable.josef.ConfirmationClaim import at.asitplus.signum.indispensable.josef.JsonWebKey import at.asitplus.signum.indispensable.josef.JsonWebKeySet @@ -25,6 +26,7 @@ import at.asitplus.signum.indispensable.josef.toJsonWebKey import at.asitplus.signum.indispensable.josef.toJwsAlgorithm import at.asitplus.signum.indispensable.pki.CertificateChain import at.asitplus.signum.indispensable.pki.X509Certificate +import at.asitplus.signum.indispensable.pki.leaf import at.asitplus.signum.indispensable.requireSupported import at.asitplus.signum.indispensable.symmetric.AuthCapability import at.asitplus.signum.indispensable.symmetric.KeyType @@ -54,7 +56,13 @@ import at.asitplus.wallet.lib.agent.KeyMaterial import at.asitplus.wallet.lib.agent.PublishedKeyMaterial import at.asitplus.wallet.lib.agent.VerifySignature import at.asitplus.wallet.lib.agent.VerifySignatureFun +import io.matthewnelson.encoding.core.Decoder.Companion.decodeToByteArray +import io.matthewnelson.encoding.core.Encoder.Companion.encodeToString +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable import kotlinx.serialization.SerializationStrategy +import kotlinx.serialization.json.decodeFromJsonElement +import kotlinx.serialization.json.jsonObject import kotlin.io.encoding.Base64 @@ -686,6 +694,60 @@ class VerifyJwsObject( } +/** + * Verifies a JWS object and additionally validates JAdES-B-B requirements, + */ +class VerifyJwsObjectJades( + val verifyJwsObject: VerifyJwsObjectFun = VerifyJwsObject(), +) : VerifyJwsObjectFun { + + @Serializable + private data class JadesX5tO( + @SerialName("digAlg") val digAlg: String, + @SerialName("digVal") val digVal: String + ) + + override suspend operator fun invoke(jwsObject: JwsSigned<*>): KmmResult = catching { + verifyJwsObject(jwsObject).getOrThrow() + validateX5tO(jwsObject).getOrThrow() + Verifier.Success + } + + private fun validateX5tO(jwsObject: JwsSigned<*>): KmmResult = catching { + val plainInputString = jwsObject.plainSignatureInput.decodeToString() + val headerB64 = plainInputString.substringBefore('.') + + val headerJsonStr = headerB64.decodeToByteArray(Base64UrlStrict).decodeToString() + + val rawHeaderJson = joseCompliantSerializer.parseToJsonElement(headerJsonStr).jsonObject + val x5tOElement = rawHeaderJson["x5t#o"] ?: return@catching + val x5tO = joseCompliantSerializer.decodeFromJsonElement(x5tOElement) + + val certChain = jwsObject.header.certificateChain + ?: throw IllegalArgumentException("JAdES Compliance Failure: 'x5t#o' parameter requires an 'x5c' certificate chain.") + + val digestAlgorithm = when (x5tO.digAlg.lowercase()) { + "sha-256", "s256" -> throw IllegalArgumentException( + "JAdES Compliance Failure: 'sha-256' is forbidden in 'x5t#o'. Use 'x5t#256' instead." + ) + "sha-384", "s384" -> Digest.SHA384 + "sha-512", "s512" -> Digest.SHA512 + else -> throw IllegalArgumentException( + "Unsupported JAdES digest algorithm: '${x5tO.digAlg}'. System supports 'sha-384' or 'sha-512'." + ) + } + + val certBytes = certChain.leaf.encodeToDer() + val calculatedHash = digestAlgorithm.digest(certBytes) + + val calculatedB64Url = calculatedHash.encodeToString(Base64UrlStrict) + + if (calculatedB64Url != x5tO.digVal) { + throw IllegalArgumentException("JAdES Integrity Violation: The calculated certificate thumbprint does not match 'x5t#o'.") + } + } +} + /** * Derives the key, for use in content encryption in JWE, * per [RFC 7518](https://datatracker.ietf.org/doc/html/rfc7518#section-5.2.2.1) diff --git a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt index 7d2d060a0..82ab23a2b 100644 --- a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt +++ b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt @@ -8,7 +8,13 @@ import at.asitplus.signum.indispensable.josef.JweEncrypted import at.asitplus.signum.indispensable.josef.JweEncryption import at.asitplus.signum.indispensable.josef.JweHeader import at.asitplus.signum.indispensable.josef.JwsHeader -import at.asitplus.testballoon.matrix.* +import at.asitplus.signum.indispensable.josef.JwsSigned +import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer +import at.asitplus.signum.indispensable.pki.leaf +import at.asitplus.signum.supreme.hash.digest +import at.asitplus.signum.supreme.sign.Verifier +import at.asitplus.testballoon.withFixtureGenerator +import at.asitplus.wallet.lib.agent.EphemeralKeyWithSelfSignedCert import at.asitplus.wallet.lib.agent.EphemeralKeyWithoutCert import at.asitplus.wallet.lib.agent.KeyMaterial import com.benasher44.uuid.uuid4 @@ -17,9 +23,13 @@ import io.kotest.assertions.throwables.shouldThrowAny import io.kotest.matchers.nulls.shouldNotBeNull import io.kotest.matchers.shouldBe import io.matthewnelson.encoding.base64.Base64 +import io.matthewnelson.encoding.core.Decoder.Companion.decodeToByteArray import io.matthewnelson.encoding.core.Encoder.Companion.encodeToString import kotlinx.serialization.builtins.ByteArraySerializer import kotlinx.serialization.builtins.serializer +import kotlinx.serialization.json.buildJsonObject +import kotlinx.serialization.json.jsonObject +import kotlinx.serialization.json.put import kotlin.random.Random val JwsServiceTest by matrixSuite { @@ -119,9 +129,128 @@ val JwsServiceTest by matrixSuite { .shouldNotBeNull() .payload shouldBe it.randomPayload } + + test("JAdES verification passes with valid x5t#o parameter (SHA-384)") { + val keyWithCert = EphemeralKeyWithSelfSignedCert() + val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) + val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + + val certBytes = baseJws.header.certificateChain!!.leaf.encodeToDer() + val calculatedHash = Digest.SHA384.digest(certBytes) + + val validB64Url = calculatedHash.encodeToString(Base64UrlStrict) + + val patchedJws = createPatchedJws(baseJws.serialize()) { + put("x5t#o", buildJsonObject { + put("digAlg", "S384") + put("digVal", validB64Url) + }) + } + + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + + jadesVerifier(patchedJws).isSuccess shouldBe true + } + + test("JAdES verification fails if x5t#o is present but x5c chain is missing") { + val baseJws = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + + val patchedJws = createPatchedJws(baseJws.serialize()) { + put("x5t#o", buildJsonObject { + put("digAlg", "S384") + put("digVal", "dummyValue") + }) + } + + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + + shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } + } + + test("JAdES verification fails if forbidden sha-256 algorithm is specified") { + val keyWithCert = EphemeralKeyWithSelfSignedCert() + val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) + val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + + val patchedJws = createPatchedJws(baseJws.serialize()) { + put("x5t#o", buildJsonObject { + put("digAlg", "S256") + put("digVal", "dummyValue") + }) + } + + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + + shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } + } + + test("JAdES verification fails if certificate thumbprint does not match digVal") { + val keyWithCert = EphemeralKeyWithSelfSignedCert() + val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) + val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + + val patchedJws = createPatchedJws(baseJws.serialize()) { + put("x5t#o", buildJsonObject { + put("digAlg", "S384") + put("digVal", "invalidMismatchedThumbprint") + }) + } + + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + + shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } + } + + test("JAdES verification skips validation and succeeds if x5t#o parameter is absent") { + val baseJws = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + + jadesVerifier(baseJws).isSuccess shouldBe true + } } } +/** + * Mutates a serialized JWS string by injecting custom parameters directly into the unverified JSON header block. + */ +fun createPatchedJws( + originalJws: String, + patcher: kotlinx.serialization.json.JsonObjectBuilder.() -> Unit +): JwsSigned { + val parts = originalJws.split(".") + val headerB64 = parts[0] + + val headerJsonStr = headerB64.decodeToByteArray(Base64UrlStrict).decodeToString() + + val rawHeaderJson = joseCompliantSerializer.parseToJsonElement(headerJsonStr).jsonObject + val updatedHeaderJson = buildJsonObject { + rawHeaderJson.forEach { (key, value) -> put(key, value) } + patcher() + } + + val updatedHeaderStr = joseCompliantSerializer.encodeToString(kotlinx.serialization.json.JsonObject.serializer(), updatedHeaderJson) + val updatedHeaderB64 = updatedHeaderStr.encodeToByteArray().encodeToString(Base64UrlStrict) + + val newJwsStr = "$updatedHeaderB64.${parts[1]}.${parts[2]}" + return JwsSigned.deserialize(ByteArraySerializer(), newJwsStr).getOrThrow() +} + /** * Identify [KeyMaterial] with it's [KeyMaterial.identifier] set in [JwsHeader.keyId], * and URL set in[JwsHeader.jsonWebKeySetUrl]. From 2862b51889a3f983375abcc591ea15eeb441244a Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 2 Jun 2026 12:22:57 +0200 Subject: [PATCH 10/16] implement LoTEClient for fetching trust lists --- .../at/asitplus/etsi/TrustListPayload.kt | 10 +++ .../src/commonMain/kotlin/LoTE/LoTEClient.kt | 66 +++++++++++++++ .../commonTest/kotlin/LoTE/LoTEClientTest.kt | 84 +++++++++++++++++++ 3 files changed, 160 insertions(+) create mode 100644 etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/TrustListPayload.kt create mode 100644 vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt create mode 100644 vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/TrustListPayload.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/TrustListPayload.kt new file mode 100644 index 000000000..b37d1f9b8 --- /dev/null +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/TrustListPayload.kt @@ -0,0 +1,10 @@ +package at.asitplus.etsi + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class TrustListPayload( + @SerialName("LoTE") + val loTe: ListOfTrustedEntities +) \ No newline at end of file diff --git a/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt b/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt new file mode 100644 index 000000000..67ff41adf --- /dev/null +++ b/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt @@ -0,0 +1,66 @@ +package LoTE + +import at.asitplus.KmmResult +import at.asitplus.catching +import at.asitplus.etsi.ListOfTrustedEntities +import at.asitplus.etsi.TrustListPayload +import at.asitplus.signum.indispensable.josef.JwsSigned +import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer +import at.asitplus.wallet.lib.jws.VerifyJwsObject +import at.asitplus.wallet.lib.jws.VerifyJwsObjectFun +import io.github.aakira.napier.Napier +import io.ktor.client.HttpClient +import io.ktor.client.HttpClientConfig +import io.ktor.client.engine.HttpClientEngine +import io.ktor.client.plugins.DefaultRequest +import io.ktor.client.plugins.contentnegotiation.ContentNegotiation +import io.ktor.client.request.accept +import io.ktor.client.request.get +import io.ktor.client.request.header +import io.ktor.client.statement.bodyAsText +import io.ktor.http.ContentType +import io.ktor.http.HttpHeaders +import io.ktor.serialization.kotlinx.json.json + +class LoTEClient( + /** ktor engine to use to make requests to the trust list service. */ + engine: HttpClientEngine, + /** Additional configuration for building the HTTP client, e.g. callers may enable logging. */ + httpClientConfig: (HttpClientConfig<*>.() -> Unit)? = null, + private val verifyJwsObject: VerifyJwsObjectFun = VerifyJwsObject(), +) { + + val client: HttpClient = HttpClient(engine) { + followRedirects = false + install(ContentNegotiation) { + json(joseCompliantSerializer) + } + install(DefaultRequest.Plugin) { + header(HttpHeaders.ContentType, ContentType.Application.Json) + } + httpClientConfig?.let { apply(it) } + } + + /** + * Fetches the signed List of Trusted Entities (LoTE) from the European Commission acceptance registry. + * Returns a [KmmResult] wrapping the [ListOfTrustedEntities] on success. + */ + suspend fun fetchTrustList(url: String): KmmResult = catching { + Napier.i("Fetching Trust List from: $url") + val response = client.get(url) { + accept(ContentType.Application.Json) + } + + val responseBody = response.bodyAsText() + val jws = JwsSigned.deserialize( + TrustListPayload.serializer(), + responseBody, + joseCompliantSerializer + ).getOrThrow() + + verifyJwsObject(jws).getOrThrow() + + Napier.i("Successfully validated Trust List signature from $url") + jws.payload.loTe + } +} \ No newline at end of file diff --git a/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt b/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt new file mode 100644 index 000000000..b11cae32e --- /dev/null +++ b/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt @@ -0,0 +1,84 @@ +package LoTE + +import at.asitplus.wallet.lib.data.MediaTypes +import at.asitplus.wallet.lib.jws.VerifyJwsObject +import at.asitplus.wallet.lib.ktor.openid.TestUtils.respond +import de.infix.testBalloon.framework.core.testSuite +import io.github.aakira.napier.Napier +import io.kotest.matchers.shouldBe +import io.kotest.matchers.shouldNotBe +import io.ktor.client.engine.cio.CIO +import io.ktor.client.engine.mock.MockEngine +import io.ktor.client.engine.mock.respond +import io.ktor.http.ContentType +import io.ktor.http.HttpHeaders +import io.ktor.http.HttpStatusCode +import io.ktor.http.headersOf +import io.ktor.utils.io.ByteReadChannel + +const val PID_PROVIDERS_JWS = "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.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.UEMFtHzX0cRw-l53OrZxeCuLIX6JBVoREuihLULVYvRfPvMJvpsoPhISDbgg3jR0RyUa8QOTQrKDAKpzOfbDty8I1RogpTfl4QMe__a5hSgGaJkFGjPJpWaKYuRUE9CIKKxTZvnErbs07R-m0SKSVZRaFnKiCac4wo5lM9Vh1OkSo0dMXto73L2TkoBL3-Xzxh8Ihsjf_mLY2Z6uh1_oVXigA5H5ZpQLkQLu3YLVbhcqbhP0h7n8nVMcrT6h4_YSMBRcG7paMszrRxBONL_UOMm9ji4nfDWwvpcpN0hheQF3mTxQrfVVTzVMrOpGbqKAKtViaykaXzmlWaonM38qauO3dGHfnyiBTXB42_ZhpIXNKknrJLkvlPBqe3l3lASagLqBuddT45Zp8B8zfU0XMbBJwBYOGS0ynufc--FrY1QfuYR_QDh9FoLBcAbDE0xO-MD0r6MfgaMXsMSvVAdqJihBOAxyvKYPIFNZ2rfoNy64Ko565k-4yLW-zIamlvremQhVt-ufrsm5oy1NKaif4z553VwVLLMdvobWZ5HS1ZhRCU2_lIYQgQvvO7Dmvl8u_DmtH3lMgkh8QuAUr03OCckFJHjoPDSX2xEUYeXpnzqeU4oL_iTgPJcBQ8Vcn4FoBHAS3J_TcydKShqg1c--fWYOZQZFFQpIBBLb51A2BpQ" +const val WALLET_PROVIDERS_JWS = "eyJhbGciOiJSUzUxMiIsImN0eSI6Impzb24iLCJraWQiOiJNRUl3TzZRNU1EY3hIREFhQmdOVkJBb01FMFYxY205d1pXRnVJRU52YlcxcGMzTnBiMjR4RnpBVkJnTlZCQU1NRGtOdmJXMXBjMU5wWjI0Z0xTQXlBZ01IclhVPSIsIng1dCNvIjp7ImRpZ0FsZyI6IlM1MTIiLCJkaWdWYWwiOiJvby1FQTRhdmt6RFZvcVViODZPUkJJOGpzOVpqX2c3RXA4NDUtY1JveTBJRWlQXzZBWHFHZDBtdW1fMzE5STAzUnNEZGNXLVVEVktoOVplb1pNeW5IQSJ9LCJ4NWMiOlsiTUlJR2J6Q0NCRmVnQXdJQkFnSURCNjExTUEwR0NTcUdTSWIzRFFFQkN3VUFNRGN4SERBYUJnTlZCQW9NRTBWMWNtOXdaV0Z1SUVOdmJXMXBjM05wYjI0eEZ6QVZCZ05WQkFNTURrTnZiVzFwYzFOcFoyNGdMU0F5TUI0WERUSXpNRGt4TlRBNE1qSXhNRm9YRFRJMk1Ea3hOVEE0TWpJeE1Gb3dhVEVMTUFrR0ExVUVCaE1DUWtVeEZEQVNCZ05WQkFzTUMwVlZVMGxIVGlCSlRsUkhNUnd3R2dZRFZRUUtEQk5GZFhKdmNHVmhiaUJEYjIxdGFYTnphVzl1TVNZd0pBWURWUVFEREIxRlZTQlRhV2R1SUhSbGMzUWdjMlZoYkNBeU1ESXpJQ2hKVGxSSEtUQ0NBaUl3RFFZSktvWklodmNOQVFFQkJRQURnZ0lQQURDQ0Fnb0NnZ0lCQUxsSVBtUVM1RUxETzE3V0NacmtCSHFieGpuZmpYRXdmamlvZHlPSFVaMm93dnZGM1lnQVZvcGd5NEZNM1JxNUhKaDZ6Y0RpRVFUbUlXcUxSODhPQjJidmhkOHpVN0wzUXFoU2NiMTE2cTIrdmxjbCtVZ2VMV3Q3bE5ES0xvZ0d5bDJ3SkNmYWtpaVdUZGIzVGtRaUhjcUtlUUI5QUF1UXBvRElsdktEdWZMcWFIUDM3ZTFDdStSbTNHYWVrRjlRL0s2bzZWUHpZcUF5NmJ4Ylp2ajUzUGNWeHFOcE5RbVc1ME9NWVZYdUdtdlZmdC9VMElSL0NxSHVTNlZrVU5sblBZNWdRbWZQRmRSM0tqWHFGUElnb2h2NnAvQm5nOXJIbjh1UFVwWHdpM29QM2R4TmgwU2VadGxhb3Y2Q1ZPZmNGRFN3RXIwNUxxMUNsYWVPSmpQZkRiOWx5MEMrbDIvUm9LSnZ2dm5LTDgxVHV1Q095UlR2SjhVS3Zma244Z0tqM1NJbURCWWU0eGx6U2RZRVNJc1N3QmhQdldqaTduUWFrMHBvWHBrc0NjRkorckpwMUQxY29COGt1R2xYM0xScVczMlRZOTlsVTVvWW5BNmtxaGJwVE9oV05NSDk1NHBFT3VuQjBYNWhJdkYwdjZsWDlOWXJVcHRSMnJMSzVLWWRPWlo3MENsRXJmbkJpVk02ZlM0MDQxK3JuL011Rjc2RjJLMGllU2duc0dBLzEzSUFOV2F3YVM1Zk5LVVNTUUU4TlBMTUw2Skp3eThuZXA4WGxkVHd5L0JBNzhmWURUUVVsV212YWVjcmo4VDhwMWF4ZnI4ZVhOQ2tIZk1JUjNYZnNrZk5Cam0xdHJWVFlIRzZQb29wWnJCQnlaTHVSUHF6OWxSWEkzR1VPUUlmQWdNQkFBR2pnZ0ZRTUlJQlREQWRCZ05WSFE0RUZnUVV2WGo5Sk94RGZnUlZpK21pemRyejRwektJOEl3SHdZRFZSMGpCQmd3Rm9BVW12dVBkbWFZM0t3czEzYzJjVzI2NDJkSGtmWXdEZ1lEVlIwUEFRSC9CQVFEQWdaQU1DTUdDQ3NHQVFVRkJ3RURCQmN3RlRBVEJnWUVBSTVHQVFZd0NRWUhCQUNPUmdFR0FqQkpCZ05WSFI4RVFqQkFNRDZnUEtBNmhqaG9kSFJ3T2k4dlkyOXRiV2x6YzJsbmJpNXdhMmt1WldNdVpYVnliM0JoTG1WMUwybHVabTh2WTNKc0wyOXViR2x1WlVOQkxtTnliRENCaVFZSUt3WUJCUVVIQVFFRWZUQjdNRVFHQ0NzR0FRVUZCekFDaGpob2RIUndPaTh2WTI5dGJXbHpjMmxuYmk1d2Eya3VaV011WlhWeWIzQmhMbVYxTDJsdVptOHZZV2xoTDI5dWJHbHVaVU5CTG1OeWREQXpCZ2dyQmdFRkJRY3dBWVluYUhSMGNEb3ZMMk52YlcxcGMzTnBaMjR1Y0d0cExtVmpMbVYxY205d1lTNWxkUzl2WTNOd01BMEdDU3FHU0liM0RRRUJDd1VBQTRJQ0FRQWVMMHlxYWt2QzQ5Z0R4b3VGdUMxbktwbmhUNDE5VU9wdS95V0ZuYmo2ajNXTUtpdXBDV3hwQ3o4ZmtDMUlqRnFQNkY4ZlIzMzIzeEpmRk1lNG5HdnRUcFpXOWhYMnp6OU0vRzU4WENqNUJHV25mVmtvRXNENzhod1F3TDRQUTJsQU5ZQ0xYL2dNQk9xWnAwdTMvempKa1ZDaTYraWdkOFZWVHhGMHBsN0U0eE8yUzdlQVk2SkU2RUE3UUdmYnI5c09MZ2xuVmpXUDZpZ0p2eWZlaGx6Um45UlRudTk4NjdRT0xobnpTQXI0MkxvM2oxdmxKcDEvQ0NYSEhJZnNQSzBDZHJSR3o4cWtZblp0TWp1bldnVG56MWEzRVpBbWh5QUVKWnZvMnNXZ0Fob1RRN2FMQ3dSOXhMY1BwK2tMcENoZGlQUHlXQStNeXBJRVNWa3ExUHBjZkduc0V5ams5R0hhZENXN2ptRERNU2xXZHR2dUtxTXFJcnpseHZKWjF0YmMwZ0xNWDRTSk5naldLL0J4VU5KdEhyczRXRjZidFQwL1NTL29qL0ttZWdaT0lFWi90bE9uZzZIUEdhckZyNGo0SVQ1elBUdVNMVVpyMEk4OWFRdUk3cElsUkx6eTcwbUNxV3FyZkFPMlpLeHFPL0J5R1RlcW9PdGQxdjZSZ1hlZFhaKzMxZTBiZCs1aU1hcExSMTlEZCtCSEd6S3BKVW1lNGZnWUNMbTk4akdJUGdZMUZVZUJMc1RDanQ1OTF0MW9VZzFYb0NocExQY3ZjbUxvZ2Y3a1FmaHlSU2dkUUdTVklFb2k1NHNXQURVU01hM0FXeWVtUnZSUkFNNjVzQXVFaVRib0NRRnkvbndhdmJRRGZQY0hxTVVhL05oNlEzWkoydGVVZHEyM1FRPT0iXSwidHlwIjoiam9zZSIsImlhdCI6MTc3OTk1ODU2M30.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":5,"LoTEType":"http://uri.etsi.org/19602/LoTEType/EUWalletProvidersList","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/wallet-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://uri.etsi.org/19602/WalletProvidersList/StatusDetn/EU","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://uri.etsi.org/19602/WalletProvidersList/schemerules/EU"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-28T08:55:37Z","NextUpdate":"2026-11-27T08:55:37Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"PagoPA Wallet Provider Root CA"}],"TETradeName":[{"lang":"en","value":"VATIT-123456789"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Test street","Locality":"Test locality","StateOrProvince":"Test province","PostalCode":"12345","Country":"IT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.it"},{"lang":"en","uriValue":"tel:+39123456789"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.it"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/IT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_eudiw_solution_it"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICUDCCAfWgAwIBAgIUONlIPSqyFQVjT6+yy1zAFLS+fOUwCgYIKoZIzj0EAwIwfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMB4XDTI1MTEyMTE2MDcxOFoXDTM1MTExOTE2MDcxOFowfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsOCKDPMrqG3DKLHAEqkutBKCBHlSmuyeQGkLL95EW4oAzqVd+1aVPfXGNKSE6dgGb2wbrcqNz/wLyoTdBh3pkaNTMFEwHQYDVR0OBBYEFFdzfeaqb/ETC5YoB4Od5h4jVD7VMB8GA1UdIwQYMBaAFFdzfeaqb/ETC5YoB4Od5h4jVD7VMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSQAwRgIhAP8LhOOEB8HPNx0sobIBQgS3Ej1rtzXcx4hggAfyFFTJAiEAmJMJA1tgB/kl2gmH5TKH2R4QaWeHmgAZSFQcdZ7yEFM="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"ojeu:eudiw:ref_eudiw_solution_it"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Test street","Locality":"Test locality","StateOrProvince":"Test province","PostalCode":"123456","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.hu"},{"lang":"en","uriValue":"tel:+36123456"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wallet_solution_ojeu_hu"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"ojeu:eudiw:ref_wallet_solution_hu"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Wallet Notification"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wallet@test.li"},{"lang":"en","uriValue":"tel:+4235002211"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/PL"}],"TEInformationExtensions":[{"OtherAssociatedBodies":[{"AssociatedBodyName":[{"lang":"en","value":"Wallet Notification Body"}],"AssociatedBodyTradeName":[{"lang":"en","value":"Liechtenstein National Administration Wallet Body"},{"lang":"en","value":"VATLI-3333"}],"AssociatedBodyAddress":{"AssociatedBodyPostalAddress":[{"lang":"en","StreetAddress":"Platz 2A","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"AssociatedBodyElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wallet-body@test.li"},{"lang":"en","uriValue":"tel:+42350022112"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet/body"}]},"AssociatedBodyInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/body/information"}]}]}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"Wallet Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/"}],"ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"REF:1234"}]}}]}]}}.HmCMQp0cbEl61X-aY-uyvnkOMy9txFR_V4ZhhSGj6K3KkOsCg-tQiJfFVOPhqECx2lPB2pNhQQeb0t4SQsC8JbP0ZN7egrglC1kDjcmnREy04F0e9BMkCENtyMM_eX74z820kj7OBzsFtpzRuQcGKFKPyvqG4aWZERLbsTGBe2tTOkHghLCmFqUi4nRQftiB4uQyv8a4BCB4AXpYRcWYXyOw1Om8Lt3cZsfGVeW7lkWsCMZO_uEfH8y1Fe9hX0r1STAnBmk4bYzJ-9xbSWNK2xTYibqIuqH-xlLyjXGYit3FFbENG5p5OlPTDXh_EpSYh-n8GTGr7O3_TQz7HmgjAgtRqc6qwi9DI9bainzAWyRA1Kglx232j1zYkNfvNrifKcE433bGikGaTgfsui0t1JHegFVRznYKfJfqzZKNs432LGDrTgS_dUNco-LnYdkDD-FOriXO1YB9gZGElrLU8Ab2_jfrgHy0-Up8de5aDtj08-swy64YBZdszN1lv1iub4VZADKPgrhnvn3Ql2g4O4rcWcvtFeMyUhKpU0NabEBuxFJoiuhysq5yRAy3lYip2DN_va-qI08QHnH7oylnX588wxy4F_TKHY4qingpbDUoJ30lVZmtT9Xvs1pnjXyep6bP-FX4R2Gf8o511qm0FyrkwrmPBr3bnuBqLsfWdfM" +const val WRPAC_PROVIDERS_JWS = "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.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":3,"LoTEType":"http://uri.etsi.org/19602/LoTEType/EUWRPACProvidersList","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://uri.etsi.org/19602/WRPACProvidersList/StatusDetn/EU","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://uri.etsi.org/19602/WRPACProvidersList/schemerules/EU"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-27T09:51:47Z","NextUpdate":"2026-11-26T09:51:47Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse RP Access CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"1234","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.no"},{"lang":"en","uriValue":"tel:+47987654"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.no"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_no"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICuzCCAmGgAwIBAgIJAKcp7ByPxFNUMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNTA5MDc1NjU0WhcNMzAwNDI5MDc1NjU0WjBkMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxKjAoBgNVBAMTIWVpZGFzMnNhbmRrYXNzZSBSUCBBY2Nlc3MgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4OQr5vpRMvcYZs46LkpdDgVQ9V+9E/Gx3Io2jqm+g/43/0b2Ns9oSRv1VpY/vYSI/O6JWylRQ+MNk6V3DfQv2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUUcgCJYAwgpE7JCLUm9xeoainXcwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDSAAwRQIgfuk68h7gRHYXzBuddxFEUGl1eYtQgMCMKcw6D1kVjzgCIQC91xg+yGdocsoPmIGACivfYZAftiQXGEjHdid9RZOX1g=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Idakto"}],"TETradeName":[{"lang":"en","value":"VATFR-12345"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"1234","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.fr"},{"lang":"en","uriValue":"tel:+33234567"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.fr"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_fr"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICgjCCAiegAwIBAgIUafRAIleaQOm9jZLiIML9FeOWd9cwCgYIKoZIzj0EAwIwczELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZSQU5DRTEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJZGFrdG8xDjAMBgNVBAsMBVN0ZWFtMSEwHwYDVQQDDBhyZWFkZXItaXNzdWVyQGlkYWt0by5jb20wHhcNMjUwNzI1MTQ0NzI1WhcNMzAwNzI0MTQ0NzI1WjBzMQswCQYDVQQGEwJGUjEPMA0GA1UECAwGRlJBTkNFMQ8wDQYDVQQHDAZBbmdlcnMxDzANBgNVBAoMBklkYWt0bzEOMAwGA1UECwwFU3RlYW0xITAfBgNVBAMMGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCq6dkUsfqjCByvS+UM/FDOgjO5fbB6aEesAgWmiMrSJQybQnAGSOySr0V+E0puM3eMaLy4DzsGLW0LX6J+vRLOjgZgwgZUwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJ57lkHy09w59xHQDk4y9ubmup5VMCsGA1UdEQQkMCKCIG9wZW5pZDR2cC5kcnVrcXMuYXNnYXJkLmlkZW52LmZyMCMGA1UdEgQcMBqBGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9hIBNw8GI7E5z/NZI/3CUMZjndoKGg+2o0lh8/6gY30CIQCiUgMnIib46Ypi4IryQOn282zPWrTWQFwIebwASeG9+w=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"2345","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.hu"},{"lang":"en","uriValue":"tel:+36567890"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_hu"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"A-SIT"}],"TETradeName":[{"lang":"en","value":"VATAT-45678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"2345","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.at"},{"lang":"en","uriValue":"tel:+43789012"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_at"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICJzCCAc6gAwIBAgIUSvMftn/oM3etHjE7hdIBl6tWMV8wCgYIKoZIzj0EAwIwMzELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMRQwEgYDVQQDDAtWYWxlcmEgSUFDQTAeFw0yNTA2MjYwODI0MDJaFw0yNjA2MjYwODI0MDJaMDMxCzAJBgNVBAYTAkFUMQ4wDAYDVQQKDAVBLVNJVDEUMBIGA1UEAwwLVmFsZXJhIElBQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQmm+pmyUxx/x2eD131E8HhvNkhsfYQXzefZlxgLXQPqCOxO+VPOXVOKL0dUy+kHyT5IP/NOAh038coAVOgGPT4o4G/MIG8MBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMCIGA1UdEgQbMBmGF2h0dHBzOi8vd2FsbGV0LmEtc2l0LmF0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHBzOi8vd2FsbGV0LmEtc2l0LmF0L2NybC8xLmNybDAfBgNVHSMEGDAWgBSDGoj0XuXE3qEVTmPvKSvIvR36ijAdBgNVHQ4EFgQUgxqI9F7lxN6hFU5j7ykryL0d+oowCgYIKoZIzj0EAwIDRwAwRAIgS9XcYA4Be5gDIdHmMOgJ3AeS44gT4bgVgsg/D5+WXS8CIAxJgi3nhGrVMj9SszehLorR2rR5FO5RZgITAaOIGSNP"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"WRPAC Provider - failing conformance checks"}],"TETradeName":[{"lang":"en","value":"WRPAC Provider1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wrpac@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/PL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"WRPAC Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/service/information"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"WRPAC Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration - WRPAC1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wrpac@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/LI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"WRPAC Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/service/information"}]}}]}]}}.ByL9Cs5ao-N11jGniNLsg068UlkwhfSwteGZIq5DGfog1vWtUvzZsAX4pCRUC1k44Y4KkIb0sYFbSp2FnV584yPJZ2LvEDl7QdyMRGwFSgJNTw7RpiDbrIj3ssziTMSMjh0Dm_6ZtHP8DrYKiMJI0ZrQhOstbsrym-Fxh9F1M2t-u8BwK1RnVCYxamCUfwYV_pLH_DJAQjv7sjjpL04TuKRLF1lIbyAG8xznjDWwzciQHart1gcgOwgVdK-llVFeQDAIeeO65dzlGVn5i7OJ1g0N1JRv6lVIawQGy6G-dK6Fl2yBtyg5M9MkRdDYbTXPIRff_cN8URtEneu0YCHFrtdzU5aqx52Xa-vdlUtxvAdt4FXP0L3jqtWnqHWbx5GHXDuhgWDhVljFNMXOH9tzomDwV2A900Yfi6v55aeCGD2MrUT5iVpY21a-mf-nEJLfY6jFfw6yeFpsfnXOrSIi4ah-A1i_1gT941GutwSSwbtPUQlTjSS4cONlLwTVbRH7zovIsw_XlHSViMcmyRbjq8QBPrqsQsEb9tS0XQ-c4a7JN6ayQnIES-3g2yiWxG1-bQFIQPSV46WhC_SF7M60eakDjL_QXPgkjm2xXFQ24d27GHsJS6zSxYZ0p2vMXXF42leNkHgMWWD4TgAF6-PrF4vzk0iD__f7KDCEty8dMk8" +const val MDL_PROVIDERS_JWS = "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.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":4,"LoTEType":"http://trust.ec.europa.eu/lists/mDL/mDLProvidersListType","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/mdl-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://trust.ec.europa.eu/lists/mDL/mDLProvidersListStatusDetn","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/schemerules"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-28T10:53:35Z","NextUpdate":"2026-11-27T10:53:35Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Agence Nationale des Titres Sécurisés"}],"TETradeName":[{"lang":"en","value":"VATFR-2356568"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"3465","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.fr"},{"lang":"en","uriValue":"tel:+337848346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.fr"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/mDLProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}},{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}},{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_3"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digitaliseringsdirektoratet - Bevisporten"}],"TETradeName":[{"lang":"en","value":"NTRNO-NOFOR.991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"5788","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+4734869323"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digitaliseringsdirektoratet - mDL-utsteder"}],"TETradeName":[{"lang":"en","value":"NTRNO-NOFOR.991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"3478","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+47348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digi- ja väestötietovirasto"}],"TETradeName":[{"lang":"en","value":"VATFI-8567"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"5685","Country":"FI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.fi"},{"lang":"en","uriValue":"tel:+358348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.fi"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/FI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fi"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse mDL Provider CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"4332","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+47348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_3"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse Pub EAA Provider CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"test","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+4734869323"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_4"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"AMA - Agência para a Modernização Administrativa"}],"TETradeName":[{"lang":"en","value":"VATPT-27373"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23451","Country":"PT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.pt"},{"lang":"en","uriValue":"tel:+35198765"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.pt"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/PT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_pt"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIC3zCCAoWgAwIBAgIUcSydOyasuB5uNjr9rj5tPAhpbQUwCgYIKoZIzj0EAwIwejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMB4XDTI0MDgyMzE4MTQ0N1oXDTMzMTExOTE4MTQ0NlowejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQQp1ekgl4ztbyvAEHQcHjiIwNRbELpVBzqXiGP2AZdhCP0qgEQ5Ud2hb0fbrE2/hEtiZmw0ppGX37g/wx+VLaOB6DCB5TASBgNVHRMBAf8ECDAGAQH/AgEAMB8GA1UdIwQYMBaAFNl5BlM1kkgig634oJOTlZRNJbezMBYGA1UdJQEB/wQMMAoGCCuBAgIAAAEHMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHBzOi8vcHJlcHJvZC5wa2kuYW1hLnByb2pqLmV1L2NybC9waWRfQ0FfMDEuY3JsMB0GA1UdDgQWBBTZeQZTNZJIIoOt+KCTk5WUTSW3szAOBgNVHQ8BAf8EBAMCAQYwIgYDVR0SBBswVIZSaHR0cHM6Ly93d3cuYW1hLmdvdi5wdC8wCgYIKoZIzj0EAwIDSAAwRQIhAPlr1TTIv8pTKOY08FpKrpNsFLj9gKIagDIUHcDPjy6iAiBL8GUS5H5NcHhTEjJxxEMX9CVuFfVhvRCssbaCV3RwsA=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"A-SIT"}],"TETradeName":[{"lang":"en","value":"VATAT-37373"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23451","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.at"},{"lang":"en","uriValue":"tel:+4398279"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_at_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"IDAKTO IACA 4"}],"TETradeName":[{"lang":"en","value":"VATFR-73829"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23343","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.fr"},{"lang":"en","uriValue":"tel:+33857302"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.fr"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_fr_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"ISO Root CA"}],"TETradeName":[{"lang":"en","value":"VATAT-90021"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"63823","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.at"},{"lang":"en","uriValue":"tel:+33848209"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_at_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Bundesdruckerei GmbH"}],"TETradeName":[{"lang":"en","value":"VATDE-82718"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"638382","Country":"DE"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.de"},{"lang":"en","uriValue":"tel:+4971501"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/DE"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_de_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"73824","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.hu"},{"lang":"en","uriValue":"tel:+36019283"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_hu_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"TEST Authority"}],"TETradeName":[{"lang":"en","value":"VATEE-373091"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"53242","Country":"EE"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.ee"},{"lang":"en","uriValue":"tel:+372932394"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.ee"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/EE"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_ee"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"GRNET"}],"TETradeName":[{"lang":"en","value":"VATEL-7283"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"53242","Country":"EL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.el"},{"lang":"en","uriValue":"tel:+302932394"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.el"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/EL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_el"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"mDL Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-mdl@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl/information"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/LI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"mDL Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}],"X509SKIs":["0RI/MTHeLnYjg8CQlPsrBXvWZLk="]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/service/information"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"mDL Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-mdl@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl/information"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/PL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"mDL Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}],"X509SKIs":["0RI/MTHeLnYjg8CQlPsrBXvWZLk="]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/service/information"}]}}]}]}}.gmYwKrXooWgMVfF9ydBl09lJ3npE7Qu34wEvWlzeXY3T7HOOC0_NmDhyj67kYDhcPAtv40zdpwyY0EgL6ZUlJJuaCfNOzQcCrX3VDrbRzU_9yJQMkN9WV8RIB_5GpP5UIlyFJMW7NvxYKyD9TE6jzeHAbPbR2ESiFdf4iQvYo1iv5V_SoknkqfPOpRYgTXAm4PdjnlZdYqe6KXuXhwu0wpVUX3sqGqzTBJPDTkaePfUxkN5uuVwIIzv9-wK5MbUp38tMA5kN_myiTBiJcecETqG1YIPpO3DplyaUCorBIsVCrOzaai_4opaObvWI7Zgjb6OU5o7vn9m84JGskCJbUI0tvmn-M5joCDGmxhfqcCY6uFgQLHWFh71Gj4ZeEk7zB97sOJB2UbOj7kgXw2JOa-6I44CTYZWH5sww2FKLUHaKK5etSZtIXF9fIbpkP_YttNpuY3OoNw0ceBPUF-FhYsKWI0gY1TNNG65mCFTNUy5_vip-fRU7zgqrZ2c8_nOeAMMKUnX6vxqSZJ8mRONlG3hk6FujARGqAlxR1RbC9BW6eT27U98uNN1ge5bzP0Lf7bwhwWBgY2PcekVO2W3a4ynSWRDceVdEesFQgSRscNxurMm11ofHVu5K6G-kcH2hbj8O8SLNYmpzwoWiDLD5dsvRtuYEKb9HT-5w-7xHKtw" + +val LoTEClientTest by testSuite { + + data class Context( + val mockEngine: MockEngine, + val client: LoTEClient, + ) + + fun setup(): Context { + val mockEngine = MockEngine { request -> + val requestedUrl = request.url.toString().substringBefore("?") + + val responsePayload = when (requestedUrl) { + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" -> PID_PROVIDERS_JWS + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wallet-providers.json" -> WALLET_PROVIDERS_JWS + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers.json" -> WRPAC_PROVIDERS_JWS + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/mdl-providers.json" -> MDL_PROVIDERS_JWS + else -> null + } + + if (responsePayload != null) { + respond( + content = ByteReadChannel(responsePayload), + status = HttpStatusCode.OK, + headers = headersOf(HttpHeaders.ContentType, MediaTypes.Application.JSON) + ) + } else { + respond( + content = ByteReadChannel("Not Found"), + status = HttpStatusCode.NotFound + ).also { Napier.w("LoTE Mock Engine: URL NOT MATCHED $requestedUrl") } + } + } + + return Context( + mockEngine = mockEngine, + client = LoTEClient( + engine = mockEngine, + verifyJwsObject = VerifyJwsObject() + ) + ) + } + + listOf( + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" to "PID Providers Acceptance", + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wallet-providers.json" to "Wallet Providers Acceptance", + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers.json" to "WRPAC Providers Acceptance", + "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/mdl-providers.json" to "mDL Providers Acceptance", + ).forEach { (url, listName) -> + + test("fetch and validate trust list: $listName") { + with(setup()) { + val result = client.fetchTrustList(url) + + result.isSuccess shouldBe true + + val lote = result.getOrThrow() + lote.trustedEntitiesList shouldNotBe null + } + } + } +} \ No newline at end of file From 051b2462e1dd97e0269997fee2c7a2178bca2130 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 2 Jun 2026 12:41:24 +0200 Subject: [PATCH 11/16] update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d086dc7ee..3dfb8787a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -52,6 +52,7 @@ Release 6.0.0 (unreleased): - Matrix testing - Add `LoTEFilterService` for extracting trust list certificates from `LoTE` based on `ServiceTypeIdentifier` - Add signature and time validity checks of certificate against the trust list + - Add JAdES B-B validation (Used when fetching LoTE) Release 5.12.0: - W3C JWT VC: From 1db44ff7f6410da71fb54990574d293af30e60a1 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Wed, 3 Jun 2026 13:59:44 +0200 Subject: [PATCH 12/16] refactor code to match new JWS data classes --- .../src/commonMain/kotlin/LoTE/LoTEClient.kt | 14 ++- .../at/asitplus/wallet/lib/jws/JwsService.kt | 18 ++-- .../asitplus/wallet/lib/jws/JwsServiceTest.kt | 102 +++++++++--------- 3 files changed, 62 insertions(+), 72 deletions(-) diff --git a/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt b/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt index 67ff41adf..17baa74cc 100644 --- a/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt +++ b/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt @@ -4,6 +4,7 @@ import at.asitplus.KmmResult import at.asitplus.catching import at.asitplus.etsi.ListOfTrustedEntities import at.asitplus.etsi.TrustListPayload +import at.asitplus.signum.indispensable.josef.JwsCompact import at.asitplus.signum.indispensable.josef.JwsSigned import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer import at.asitplus.wallet.lib.jws.VerifyJwsObject @@ -42,7 +43,7 @@ class LoTEClient( } /** - * Fetches the signed List of Trusted Entities (LoTE) from the European Commission acceptance registry. + * Fetches the signed List of Trusted Entities (LoTE) * Returns a [KmmResult] wrapping the [ListOfTrustedEntities] on success. */ suspend fun fetchTrustList(url: String): KmmResult = catching { @@ -52,15 +53,12 @@ class LoTEClient( } val responseBody = response.bodyAsText() - val jws = JwsSigned.deserialize( - TrustListPayload.serializer(), - responseBody, - joseCompliantSerializer - ).getOrThrow() - verifyJwsObject(jws).getOrThrow() + val (jwsCompact, payload) = JwsCompact.parse(responseBody).getOrThrow() + + verifyJwsObject(jwsCompact).getOrThrow() Napier.i("Successfully validated Trust List signature from $url") - jws.payload.loTe + payload.loTe } } \ No newline at end of file diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt index c7097e4ac..6b8106999 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/jws/JwsService.kt @@ -695,7 +695,7 @@ class VerifyJwsObject( } /** - * Verifies a JWS object and additionally validates JAdES-B-B requirements, + * Verifies a JWS object and additionally validates JAdES-B-B requirements. */ class VerifyJwsObjectJades( val verifyJwsObject: VerifyJwsObjectFun = VerifyJwsObject(), @@ -707,23 +707,20 @@ class VerifyJwsObjectJades( @SerialName("digVal") val digVal: String ) - override suspend operator fun invoke(jwsObject: JwsSigned<*>): KmmResult = catching { - verifyJwsObject(jwsObject).getOrThrow() + override suspend operator fun invoke(jwsObject: JwsCompact): KmmResult = catching { + verifyJwsObject(jwsObject).getOrThrow() // This internally uses plainSignature and signatureInput validateX5tO(jwsObject).getOrThrow() Verifier.Success } - private fun validateX5tO(jwsObject: JwsSigned<*>): KmmResult = catching { - val plainInputString = jwsObject.plainSignatureInput.decodeToString() - val headerB64 = plainInputString.substringBefore('.') - - val headerJsonStr = headerB64.decodeToByteArray(Base64UrlStrict).decodeToString() - + private fun validateX5tO(jwsObject: JwsCompact): KmmResult = catching { + val headerJsonStr = jwsObject.plainProtectedHeader.decodeToString() val rawHeaderJson = joseCompliantSerializer.parseToJsonElement(headerJsonStr).jsonObject + val x5tOElement = rawHeaderJson["x5t#o"] ?: return@catching val x5tO = joseCompliantSerializer.decodeFromJsonElement(x5tOElement) - val certChain = jwsObject.header.certificateChain + val certChain = jwsObject.jwsHeader.certificateChain ?: throw IllegalArgumentException("JAdES Compliance Failure: 'x5t#o' parameter requires an 'x5c' certificate chain.") val digestAlgorithm = when (x5tO.digAlg.lowercase()) { @@ -739,7 +736,6 @@ class VerifyJwsObjectJades( val certBytes = certChain.leaf.encodeToDer() val calculatedHash = digestAlgorithm.digest(certBytes) - val calculatedB64Url = calculatedHash.encodeToString(Base64UrlStrict) if (calculatedB64Url != x5tO.digVal) { diff --git a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt index 82ab23a2b..d020e5bf7 100644 --- a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt +++ b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt @@ -1,5 +1,8 @@ package at.asitplus.wallet.lib.jws +import at.asitplus.catching +import at.asitplus.dcapi.request.DCAPIWalletRequest +import at.asitplus.signum.indispensable.Digest import at.asitplus.signum.indispensable.josef.JwsCompactTyped import at.asitplus.signum.indispensable.io.Base64UrlStrict import at.asitplus.signum.indispensable.josef.JsonWebKeySet @@ -7,6 +10,7 @@ import at.asitplus.signum.indispensable.josef.JweAlgorithm import at.asitplus.signum.indispensable.josef.JweEncrypted import at.asitplus.signum.indispensable.josef.JweEncryption import at.asitplus.signum.indispensable.josef.JweHeader +import at.asitplus.signum.indispensable.josef.JwsCompact import at.asitplus.signum.indispensable.josef.JwsHeader import at.asitplus.signum.indispensable.josef.JwsSigned import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer @@ -27,9 +31,11 @@ import io.matthewnelson.encoding.core.Decoder.Companion.decodeToByteArray import io.matthewnelson.encoding.core.Encoder.Companion.encodeToString import kotlinx.serialization.builtins.ByteArraySerializer import kotlinx.serialization.builtins.serializer +import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.buildJsonObject import kotlinx.serialization.json.jsonObject import kotlinx.serialization.json.put +import net.orandja.obor.codec.Cbor.Companion.copy import kotlin.random.Random val JwsServiceTest by matrixSuite { @@ -130,125 +136,115 @@ val JwsServiceTest by matrixSuite { .payload shouldBe it.randomPayload } + val dummyVerifier = object : VerifyJwsObjectFun { + override suspend fun invoke(jwsObject: JwsCompact) = catching { Verifier.Success } + } + val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) + test("JAdES verification passes with valid x5t#o parameter (SHA-384)") { val keyWithCert = EphemeralKeyWithSelfSignedCert() - val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) - val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + val signed = SignJwt(keyWithCert, JwsHeaderCertOrJwk())( + JwsContentTypeConstants.JWT, + it.randomPayload.encodeToByteArray(), + ByteArraySerializer() + ).getOrThrow() - val certBytes = baseJws.header.certificateChain!!.leaf.encodeToDer() - val calculatedHash = Digest.SHA384.digest(certBytes) + // Extract the actual JwsCompact to match the rest of the test suite + val baseJws = signed.jws - val validB64Url = calculatedHash.encodeToString(Base64UrlStrict) + val validB64Url = Digest.SHA384 + .digest(baseJws.jwsHeader.certificateChain!!.leaf.encodeToDer()) + .encodeToString(Base64UrlStrict) - val patchedJws = createPatchedJws(baseJws.serialize()) { + val patchedJws = baseJws.patchHeader { put("x5t#o", buildJsonObject { put("digAlg", "S384") put("digVal", validB64Url) }) } - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } - } - val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) - jadesVerifier(patchedJws).isSuccess shouldBe true } test("JAdES verification fails if x5t#o is present but x5c chain is missing") { - val baseJws = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + val signed = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() - val patchedJws = createPatchedJws(baseJws.serialize()) { + // Call .patchHeader on .jws + val patchedJws = signed.jws.patchHeader { put("x5t#o", buildJsonObject { put("digAlg", "S384") put("digVal", "dummyValue") }) } - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } - } - val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) - shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } } test("JAdES verification fails if forbidden sha-256 algorithm is specified") { val keyWithCert = EphemeralKeyWithSelfSignedCert() - val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) - val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + val signed = SignJwt(keyWithCert, JwsHeaderCertOrJwk())( + JwsContentTypeConstants.JWT, + it.randomPayload.encodeToByteArray(), + ByteArraySerializer() + ).getOrThrow() - val patchedJws = createPatchedJws(baseJws.serialize()) { + val patchedJws = signed.jws.patchHeader { put("x5t#o", buildJsonObject { put("digAlg", "S256") put("digVal", "dummyValue") }) } - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } - } - val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) - shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } } test("JAdES verification fails if certificate thumbprint does not match digVal") { val keyWithCert = EphemeralKeyWithSelfSignedCert() - val signer = SignJwt(keyWithCert, JwsHeaderCertOrJwk()) - val baseJws = signer(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + val signed = SignJwt(keyWithCert, JwsHeaderCertOrJwk())( + JwsContentTypeConstants.JWT, + it.randomPayload.encodeToByteArray(), + ByteArraySerializer() + ).getOrThrow() - val patchedJws = createPatchedJws(baseJws.serialize()) { + val patchedJws = signed.jws.patchHeader { put("x5t#o", buildJsonObject { put("digAlg", "S384") put("digVal", "invalidMismatchedThumbprint") }) } - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } - } - val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) - shouldThrowAny { jadesVerifier(patchedJws).getOrThrow() } } test("JAdES verification skips validation and succeeds if x5t#o parameter is absent") { - val baseJws = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() + val signed = it.signJwt(JwsContentTypeConstants.JWT, it.randomPayload.encodeToByteArray(), ByteArraySerializer()).getOrThrow() - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsSigned<*>) = catching { Verifier.Success } - } - val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) - - jadesVerifier(baseJws).isSuccess shouldBe true + jadesVerifier(signed.jws).isSuccess shouldBe true } } } /** * Mutates a serialized JWS string by injecting custom parameters directly into the unverified JSON header block. + * NOTE: This deliberately invalidates the cryptographic signature. Use for testing only. */ -fun createPatchedJws( - originalJws: String, - patcher: kotlinx.serialization.json.JsonObjectBuilder.() -> Unit -): JwsSigned { - val parts = originalJws.split(".") - val headerB64 = parts[0] - - val headerJsonStr = headerB64.decodeToByteArray(Base64UrlStrict).decodeToString() +fun JwsCompact.patchHeader(patcher: kotlinx.serialization.json.JsonObjectBuilder.() -> Unit): JwsCompact { + val rawHeaderJson = joseCompliantSerializer.decodeFromString(plainProtectedHeader.decodeToString()) - val rawHeaderJson = joseCompliantSerializer.parseToJsonElement(headerJsonStr).jsonObject val updatedHeaderJson = buildJsonObject { rawHeaderJson.forEach { (key, value) -> put(key, value) } patcher() } - val updatedHeaderStr = joseCompliantSerializer.encodeToString(kotlinx.serialization.json.JsonObject.serializer(), updatedHeaderJson) - val updatedHeaderB64 = updatedHeaderStr.encodeToByteArray().encodeToString(Base64UrlStrict) + val updatedHeaderB64 = joseCompliantSerializer + .encodeToString(JsonObject.serializer(), updatedHeaderJson) + .encodeToByteArray() + .encodeToString(Base64UrlStrict) + val parts = this.toString().split('.') val newJwsStr = "$updatedHeaderB64.${parts[1]}.${parts[2]}" - return JwsSigned.deserialize(ByteArraySerializer(), newJwsStr).getOrThrow() + + return JwsCompact(newJwsStr) } /** From a94e5d5a928b0de3ca9ee34bf1816a646b420d93 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Tue, 16 Jun 2026 16:12:05 +0200 Subject: [PATCH 13/16] add storing issuer in credential store --- .../at/asitplus/wallet/lib/agent/HolderAgent.kt | 10 +++++++--- .../lib/agent/InMemorySubjectCredentialStore.kt | 3 +++ .../wallet/lib/agent/SubjectCredentialStore.kt | 13 ++++++++++++- 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/HolderAgent.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/HolderAgent.kt index 30406791a..a0bb65d22 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/HolderAgent.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/HolderAgent.kt @@ -15,6 +15,7 @@ import at.asitplus.openid.dcql.DCQLQuery import at.asitplus.signum.indispensable.cosef.CoseKey import at.asitplus.signum.indispensable.cosef.toCoseKey import at.asitplus.signum.indispensable.pki.X509Certificate +import at.asitplus.signum.indispensable.pki.leaf import at.asitplus.wallet.lib.agent.SubjectCredentialStore.StoreEntry import at.asitplus.wallet.lib.data.CredentialPresentation import at.asitplus.wallet.lib.data.CredentialPresentationRequest @@ -68,7 +69,8 @@ class HolderAgent( vc = validated.jws, vcSerialized = credential.vcJws, scheme = credential.scheme, - renewalInfo = renewalInfo + renewalInfo = renewalInfo, + issuer = credential.signedVcJws.jws.jwsHeader.certificateChain?.leaf?.encodeToDerOrNull() ) } @@ -82,7 +84,8 @@ class HolderAgent( vcSerialized = credential.vcSdJwt, disclosures = validated.disclosures, scheme = credential.scheme, - renewalInfo = renewalInfo + renewalInfo = renewalInfo, + issuer = credential.signedSdJwtVc.jws.jwsHeader.certificateChain?.leaf?.encodeToDerOrNull() ) } @@ -92,7 +95,8 @@ class HolderAgent( subjectCredentialStore.storeCredential( issuerSigned = validated.issuerSigned, scheme = credential.scheme, - renewalInfo = renewalInfo + renewalInfo = renewalInfo, + issuer = credential.issuerSigned.issuerAuth.unprotectedHeader?.certificateChain?.getOrNull(0) ) } } diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/InMemorySubjectCredentialStore.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/InMemorySubjectCredentialStore.kt index 86ab2a69f..81bf0545b 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/InMemorySubjectCredentialStore.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/InMemorySubjectCredentialStore.kt @@ -17,6 +17,7 @@ class InMemorySubjectCredentialStore : SubjectCredentialStore { vcSerialized: String, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo?, + issuer: ByteArray? ) = SubjectCredentialStore.StoreEntry.Vc(vcSerialized, vc, scheme.schemaUri, renewalInfo) .also { credentials += it } @@ -26,6 +27,7 @@ class InMemorySubjectCredentialStore : SubjectCredentialStore { disclosures: Map, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo?, + issuer: ByteArray? ) = SubjectCredentialStore.StoreEntry.SdJwt(vcSerialized, vc, disclosures, scheme.schemaUri, renewalInfo) .also { credentials += it } @@ -33,6 +35,7 @@ class InMemorySubjectCredentialStore : SubjectCredentialStore { issuerSigned: IssuerSigned, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo?, + issuer: ByteArray? ) = SubjectCredentialStore.StoreEntry.Iso(issuerSigned, scheme.schemaUri, renewalInfo) .also { credentials += it } diff --git a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/SubjectCredentialStore.kt b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/SubjectCredentialStore.kt index cfa1da893..3759c1b5f 100644 --- a/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/SubjectCredentialStore.kt +++ b/vck/src/commonMain/kotlin/at/asitplus/wallet/lib/agent/SubjectCredentialStore.kt @@ -11,6 +11,7 @@ import at.asitplus.openid.OAuth2AuthorizationServerMetadata import at.asitplus.openid.SupportedCredentialFormat import at.asitplus.signum.indispensable.cosef.io.coseCompliantSerializer import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer +import at.asitplus.signum.indispensable.pki.X509Certificate import at.asitplus.wallet.lib.data.AttributeIndex import at.asitplus.wallet.lib.data.ConstantIndex import at.asitplus.wallet.lib.data.IsoMdocFallbackCredentialScheme @@ -43,6 +44,7 @@ interface SubjectCredentialStore { vcSerialized: String, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo? = null, + issuer: ByteArray? = null ): StoreEntry /** @@ -58,6 +60,7 @@ interface SubjectCredentialStore { disclosures: Map, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo? = null, + issuer: ByteArray? = null ): StoreEntry /** @@ -70,6 +73,7 @@ interface SubjectCredentialStore { issuerSigned: IssuerSigned, scheme: ConstantIndex.CredentialScheme, renewalInfo: CredentialRenewalInfo? = null, + issuer: ByteArray? = null ): StoreEntry /** @@ -87,6 +91,7 @@ interface SubjectCredentialStore { val credentialFormat: CredentialFormatEnum val claimFormat: ClaimFormat val renewalInfo: CredentialRenewalInfo? + val issuer: ByteArray? fun getFallbackScheme(): ConstantIndex.CredentialScheme? @@ -100,6 +105,8 @@ interface SubjectCredentialStore { override val schemaUri: String, @SerialName("credential-renewal-info") override val renewalInfo: CredentialRenewalInfo? = null, + @SerialName("issuer") + override val issuer: ByteArray? = null, ) : StoreEntry { override fun getFallbackScheme(): ConstantIndex.CredentialScheme = VcFallbackCredentialScheme(vc.vc.type.first { it != VERIFIABLE_CREDENTIAL }) @@ -121,6 +128,8 @@ interface SubjectCredentialStore { override val schemaUri: String, @SerialName("credential-renewal-info") override val renewalInfo: CredentialRenewalInfo? = null, + @SerialName("issuer") + override val issuer: ByteArray? = null ) : StoreEntry { override fun getFallbackScheme(): ConstantIndex.CredentialScheme = SdJwtFallbackCredentialScheme(sdJwt.verifiableCredentialType) @@ -137,6 +146,8 @@ interface SubjectCredentialStore { override val schemaUri: String, @SerialName("credential-renewal-info") override val renewalInfo: CredentialRenewalInfo? = null, + @SerialName("issuer") + override val issuer: ByteArray? = null ) : StoreEntry { override fun getFallbackScheme(): ConstantIndex.CredentialScheme? = catchingUnwrapped { IsoMdocFallbackCredentialScheme(issuerSigned.issuerAuth.payload?.docType!!) @@ -171,4 +182,4 @@ data class CredentialRenewalInfo( val oauthMetadata: OAuth2AuthorizationServerMetadata, val credentialFormat: SupportedCredentialFormat, val credentialIdentifier: String, -) +) \ No newline at end of file From b5476a179f73149e6c486af12c77ad516de8d065 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Wed, 17 Jun 2026 10:54:40 +0200 Subject: [PATCH 14/16] update to matrix testing --- .../src/commonMain/kotlin/LoTE/LoTEClient.kt | 64 -------------- .../commonTest/kotlin/LoTE/LoTEClientTest.kt | 84 ------------------- .../asitplus/wallet/lib/jws/JwsServiceTest.kt | 13 +-- .../wallet/lib/etsi/LoTEFilterTest.kt | 11 ++- .../wallet/lib/etsi/TrustListValidatorTest.kt | 5 +- 5 files changed, 10 insertions(+), 167 deletions(-) delete mode 100644 vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt delete mode 100644 vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt diff --git a/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt b/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt deleted file mode 100644 index 17baa74cc..000000000 --- a/vck-openid-ktor/src/commonMain/kotlin/LoTE/LoTEClient.kt +++ /dev/null @@ -1,64 +0,0 @@ -package LoTE - -import at.asitplus.KmmResult -import at.asitplus.catching -import at.asitplus.etsi.ListOfTrustedEntities -import at.asitplus.etsi.TrustListPayload -import at.asitplus.signum.indispensable.josef.JwsCompact -import at.asitplus.signum.indispensable.josef.JwsSigned -import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer -import at.asitplus.wallet.lib.jws.VerifyJwsObject -import at.asitplus.wallet.lib.jws.VerifyJwsObjectFun -import io.github.aakira.napier.Napier -import io.ktor.client.HttpClient -import io.ktor.client.HttpClientConfig -import io.ktor.client.engine.HttpClientEngine -import io.ktor.client.plugins.DefaultRequest -import io.ktor.client.plugins.contentnegotiation.ContentNegotiation -import io.ktor.client.request.accept -import io.ktor.client.request.get -import io.ktor.client.request.header -import io.ktor.client.statement.bodyAsText -import io.ktor.http.ContentType -import io.ktor.http.HttpHeaders -import io.ktor.serialization.kotlinx.json.json - -class LoTEClient( - /** ktor engine to use to make requests to the trust list service. */ - engine: HttpClientEngine, - /** Additional configuration for building the HTTP client, e.g. callers may enable logging. */ - httpClientConfig: (HttpClientConfig<*>.() -> Unit)? = null, - private val verifyJwsObject: VerifyJwsObjectFun = VerifyJwsObject(), -) { - - val client: HttpClient = HttpClient(engine) { - followRedirects = false - install(ContentNegotiation) { - json(joseCompliantSerializer) - } - install(DefaultRequest.Plugin) { - header(HttpHeaders.ContentType, ContentType.Application.Json) - } - httpClientConfig?.let { apply(it) } - } - - /** - * Fetches the signed List of Trusted Entities (LoTE) - * Returns a [KmmResult] wrapping the [ListOfTrustedEntities] on success. - */ - suspend fun fetchTrustList(url: String): KmmResult = catching { - Napier.i("Fetching Trust List from: $url") - val response = client.get(url) { - accept(ContentType.Application.Json) - } - - val responseBody = response.bodyAsText() - - val (jwsCompact, payload) = JwsCompact.parse(responseBody).getOrThrow() - - verifyJwsObject(jwsCompact).getOrThrow() - - Napier.i("Successfully validated Trust List signature from $url") - payload.loTe - } -} \ No newline at end of file diff --git a/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt b/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt deleted file mode 100644 index b11cae32e..000000000 --- a/vck-openid-ktor/src/commonTest/kotlin/LoTE/LoTEClientTest.kt +++ /dev/null @@ -1,84 +0,0 @@ -package LoTE - -import at.asitplus.wallet.lib.data.MediaTypes -import at.asitplus.wallet.lib.jws.VerifyJwsObject -import at.asitplus.wallet.lib.ktor.openid.TestUtils.respond -import de.infix.testBalloon.framework.core.testSuite -import io.github.aakira.napier.Napier -import io.kotest.matchers.shouldBe -import io.kotest.matchers.shouldNotBe -import io.ktor.client.engine.cio.CIO -import io.ktor.client.engine.mock.MockEngine -import io.ktor.client.engine.mock.respond -import io.ktor.http.ContentType -import io.ktor.http.HttpHeaders -import io.ktor.http.HttpStatusCode -import io.ktor.http.headersOf -import io.ktor.utils.io.ByteReadChannel - -const val PID_PROVIDERS_JWS = "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.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.UEMFtHzX0cRw-l53OrZxeCuLIX6JBVoREuihLULVYvRfPvMJvpsoPhISDbgg3jR0RyUa8QOTQrKDAKpzOfbDty8I1RogpTfl4QMe__a5hSgGaJkFGjPJpWaKYuRUE9CIKKxTZvnErbs07R-m0SKSVZRaFnKiCac4wo5lM9Vh1OkSo0dMXto73L2TkoBL3-Xzxh8Ihsjf_mLY2Z6uh1_oVXigA5H5ZpQLkQLu3YLVbhcqbhP0h7n8nVMcrT6h4_YSMBRcG7paMszrRxBONL_UOMm9ji4nfDWwvpcpN0hheQF3mTxQrfVVTzVMrOpGbqKAKtViaykaXzmlWaonM38qauO3dGHfnyiBTXB42_ZhpIXNKknrJLkvlPBqe3l3lASagLqBuddT45Zp8B8zfU0XMbBJwBYOGS0ynufc--FrY1QfuYR_QDh9FoLBcAbDE0xO-MD0r6MfgaMXsMSvVAdqJihBOAxyvKYPIFNZ2rfoNy64Ko565k-4yLW-zIamlvremQhVt-ufrsm5oy1NKaif4z553VwVLLMdvobWZ5HS1ZhRCU2_lIYQgQvvO7Dmvl8u_DmtH3lMgkh8QuAUr03OCckFJHjoPDSX2xEUYeXpnzqeU4oL_iTgPJcBQ8Vcn4FoBHAS3J_TcydKShqg1c--fWYOZQZFFQpIBBLb51A2BpQ" -const val WALLET_PROVIDERS_JWS = "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.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":5,"LoTEType":"http://uri.etsi.org/19602/LoTEType/EUWalletProvidersList","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/wallet-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://uri.etsi.org/19602/WalletProvidersList/StatusDetn/EU","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://uri.etsi.org/19602/WalletProvidersList/schemerules/EU"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-28T08:55:37Z","NextUpdate":"2026-11-27T08:55:37Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"PagoPA Wallet Provider Root CA"}],"TETradeName":[{"lang":"en","value":"VATIT-123456789"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Test street","Locality":"Test locality","StateOrProvince":"Test province","PostalCode":"12345","Country":"IT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.it"},{"lang":"en","uriValue":"tel:+39123456789"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.it"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/IT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_eudiw_solution_it"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICUDCCAfWgAwIBAgIUONlIPSqyFQVjT6+yy1zAFLS+fOUwCgYIKoZIzj0EAwIwfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMB4XDTI1MTEyMTE2MDcxOFoXDTM1MTExOTE2MDcxOFowfTELMAkGA1UEBhMCSVQxCzAJBgNVBAgMAlJNMQ0wCwYDVQQHDARSb21lMRYwFAYDVQQKDA1QYWdvUEEgUy5wLkEuMREwDwYDVQQLDAhTZWN1cml0eTEnMCUGA1UEAwweUGFnb1BBIFdhbGxldCBQcm92aWRlciBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEsOCKDPMrqG3DKLHAEqkutBKCBHlSmuyeQGkLL95EW4oAzqVd+1aVPfXGNKSE6dgGb2wbrcqNz/wLyoTdBh3pkaNTMFEwHQYDVR0OBBYEFFdzfeaqb/ETC5YoB4Od5h4jVD7VMB8GA1UdIwQYMBaAFFdzfeaqb/ETC5YoB4Od5h4jVD7VMA8GA1UdEwEB/wQFMAMBAf8wCgYIKoZIzj0EAwIDSQAwRgIhAP8LhOOEB8HPNx0sobIBQgS3Ej1rtzXcx4hggAfyFFTJAiEAmJMJA1tgB/kl2gmH5TKH2R4QaWeHmgAZSFQcdZ7yEFM="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"ojeu:eudiw:ref_eudiw_solution_it"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Test street","Locality":"Test locality","StateOrProvince":"Test province","PostalCode":"123456","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.hu"},{"lang":"en","uriValue":"tel:+36123456"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wallet_solution_ojeu_hu"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"ojeu:eudiw:ref_wallet_solution_hu"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Wallet Notification"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wallet@test.li"},{"lang":"en","uriValue":"tel:+4235002211"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WalletProvider/PL"}],"TEInformationExtensions":[{"OtherAssociatedBodies":[{"AssociatedBodyName":[{"lang":"en","value":"Wallet Notification Body"}],"AssociatedBodyTradeName":[{"lang":"en","value":"Liechtenstein National Administration Wallet Body"},{"lang":"en","value":"VATLI-3333"}],"AssociatedBodyAddress":{"AssociatedBodyPostalAddress":[{"lang":"en","StreetAddress":"Platz 2A","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"AssociatedBodyElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wallet-body@test.li"},{"lang":"en","uriValue":"tel:+42350022112"},{"lang":"en","uriValue":"https://www.llv.li/en/wallet/body"}]},"AssociatedBodyInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/body/information"}]}]}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"Wallet Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wallet/"}],"ServiceInformationExtensions":[{"ServiceUniqueIdentifier":"REF:1234"}]}}]}]}}.HmCMQp0cbEl61X-aY-uyvnkOMy9txFR_V4ZhhSGj6K3KkOsCg-tQiJfFVOPhqECx2lPB2pNhQQeb0t4SQsC8JbP0ZN7egrglC1kDjcmnREy04F0e9BMkCENtyMM_eX74z820kj7OBzsFtpzRuQcGKFKPyvqG4aWZERLbsTGBe2tTOkHghLCmFqUi4nRQftiB4uQyv8a4BCB4AXpYRcWYXyOw1Om8Lt3cZsfGVeW7lkWsCMZO_uEfH8y1Fe9hX0r1STAnBmk4bYzJ-9xbSWNK2xTYibqIuqH-xlLyjXGYit3FFbENG5p5OlPTDXh_EpSYh-n8GTGr7O3_TQz7HmgjAgtRqc6qwi9DI9bainzAWyRA1Kglx232j1zYkNfvNrifKcE433bGikGaTgfsui0t1JHegFVRznYKfJfqzZKNs432LGDrTgS_dUNco-LnYdkDD-FOriXO1YB9gZGElrLU8Ab2_jfrgHy0-Up8de5aDtj08-swy64YBZdszN1lv1iub4VZADKPgrhnvn3Ql2g4O4rcWcvtFeMyUhKpU0NabEBuxFJoiuhysq5yRAy3lYip2DN_va-qI08QHnH7oylnX588wxy4F_TKHY4qingpbDUoJ30lVZmtT9Xvs1pnjXyep6bP-FX4R2Gf8o511qm0FyrkwrmPBr3bnuBqLsfWdfM" -const val WRPAC_PROVIDERS_JWS = "eyJhbGciOiJSUzUxMiIsImN0eSI6Impzb24iLCJraWQiOiJNRUl3TzZRNU1EY3hIREFhQmdOVkJBb01FMFYxY205d1pXRnVJRU52YlcxcGMzTnBiMjR4RnpBVkJnTlZCQU1NRGtOdmJXMXBjMU5wWjI0Z0xTQXlBZ01IclhVPSIsIng1dCNvIjp7ImRpZ0FsZyI6IlM1MTIiLCJkaWdWYWwiOiJvby1FQTRhdmt6RFZvcVViODZPUkJJOGpzOVpqX2c3RXA4NDUtY1JveTBJRWlQXzZBWHFHZDBtdW1fMzE5STAzUnNEZGNXLVVEVktoOVplb1pNeW5IQSJ9LCJ4NWMiOlsiTUlJR2J6Q0NCRmVnQXdJQkFnSURCNjExTUEwR0NTcUdTSWIzRFFFQkN3VUFNRGN4SERBYUJnTlZCQW9NRTBWMWNtOXdaV0Z1SUVOdmJXMXBjM05wYjI0eEZ6QVZCZ05WQkFNTURrTnZiVzFwYzFOcFoyNGdMU0F5TUI0WERUSXpNRGt4TlRBNE1qSXhNRm9YRFRJMk1Ea3hOVEE0TWpJeE1Gb3dhVEVMTUFrR0ExVUVCaE1DUWtVeEZEQVNCZ05WQkFzTUMwVlZVMGxIVGlCSlRsUkhNUnd3R2dZRFZRUUtEQk5GZFhKdmNHVmhiaUJEYjIxdGFYTnphVzl1TVNZd0pBWURWUVFEREIxRlZTQlRhV2R1SUhSbGMzUWdjMlZoYkNBeU1ESXpJQ2hKVGxSSEtUQ0NBaUl3RFFZSktvWklodmNOQVFFQkJRQURnZ0lQQURDQ0Fnb0NnZ0lCQUxsSVBtUVM1RUxETzE3V0NacmtCSHFieGpuZmpYRXdmamlvZHlPSFVaMm93dnZGM1lnQVZvcGd5NEZNM1JxNUhKaDZ6Y0RpRVFUbUlXcUxSODhPQjJidmhkOHpVN0wzUXFoU2NiMTE2cTIrdmxjbCtVZ2VMV3Q3bE5ES0xvZ0d5bDJ3SkNmYWtpaVdUZGIzVGtRaUhjcUtlUUI5QUF1UXBvRElsdktEdWZMcWFIUDM3ZTFDdStSbTNHYWVrRjlRL0s2bzZWUHpZcUF5NmJ4Ylp2ajUzUGNWeHFOcE5RbVc1ME9NWVZYdUdtdlZmdC9VMElSL0NxSHVTNlZrVU5sblBZNWdRbWZQRmRSM0tqWHFGUElnb2h2NnAvQm5nOXJIbjh1UFVwWHdpM29QM2R4TmgwU2VadGxhb3Y2Q1ZPZmNGRFN3RXIwNUxxMUNsYWVPSmpQZkRiOWx5MEMrbDIvUm9LSnZ2dm5LTDgxVHV1Q095UlR2SjhVS3Zma244Z0tqM1NJbURCWWU0eGx6U2RZRVNJc1N3QmhQdldqaTduUWFrMHBvWHBrc0NjRkorckpwMUQxY29COGt1R2xYM0xScVczMlRZOTlsVTVvWW5BNmtxaGJwVE9oV05NSDk1NHBFT3VuQjBYNWhJdkYwdjZsWDlOWXJVcHRSMnJMSzVLWWRPWlo3MENsRXJmbkJpVk02ZlM0MDQxK3JuL011Rjc2RjJLMGllU2duc0dBLzEzSUFOV2F3YVM1Zk5LVVNTUUU4TlBMTUw2Skp3eThuZXA4WGxkVHd5L0JBNzhmWURUUVVsV212YWVjcmo4VDhwMWF4ZnI4ZVhOQ2tIZk1JUjNYZnNrZk5Cam0xdHJWVFlIRzZQb29wWnJCQnlaTHVSUHF6OWxSWEkzR1VPUUlmQWdNQkFBR2pnZ0ZRTUlJQlREQWRCZ05WSFE0RUZnUVV2WGo5Sk94RGZnUlZpK21pemRyejRwektJOEl3SHdZRFZSMGpCQmd3Rm9BVW12dVBkbWFZM0t3czEzYzJjVzI2NDJkSGtmWXdEZ1lEVlIwUEFRSC9CQVFEQWdaQU1DTUdDQ3NHQVFVRkJ3RURCQmN3RlRBVEJnWUVBSTVHQVFZd0NRWUhCQUNPUmdFR0FqQkpCZ05WSFI4RVFqQkFNRDZnUEtBNmhqaG9kSFJ3T2k4dlkyOXRiV2x6YzJsbmJpNXdhMmt1WldNdVpYVnliM0JoTG1WMUwybHVabTh2WTNKc0wyOXViR2x1WlVOQkxtTnliRENCaVFZSUt3WUJCUVVIQVFFRWZUQjdNRVFHQ0NzR0FRVUZCekFDaGpob2RIUndPaTh2WTI5dGJXbHpjMmxuYmk1d2Eya3VaV011WlhWeWIzQmhMbVYxTDJsdVptOHZZV2xoTDI5dWJHbHVaVU5CTG1OeWREQXpCZ2dyQmdFRkJRY3dBWVluYUhSMGNEb3ZMMk52YlcxcGMzTnBaMjR1Y0d0cExtVmpMbVYxY205d1lTNWxkUzl2WTNOd01BMEdDU3FHU0liM0RRRUJDd1VBQTRJQ0FRQWVMMHlxYWt2QzQ5Z0R4b3VGdUMxbktwbmhUNDE5VU9wdS95V0ZuYmo2ajNXTUtpdXBDV3hwQ3o4ZmtDMUlqRnFQNkY4ZlIzMzIzeEpmRk1lNG5HdnRUcFpXOWhYMnp6OU0vRzU4WENqNUJHV25mVmtvRXNENzhod1F3TDRQUTJsQU5ZQ0xYL2dNQk9xWnAwdTMvempKa1ZDaTYraWdkOFZWVHhGMHBsN0U0eE8yUzdlQVk2SkU2RUE3UUdmYnI5c09MZ2xuVmpXUDZpZ0p2eWZlaGx6Um45UlRudTk4NjdRT0xobnpTQXI0MkxvM2oxdmxKcDEvQ0NYSEhJZnNQSzBDZHJSR3o4cWtZblp0TWp1bldnVG56MWEzRVpBbWh5QUVKWnZvMnNXZ0Fob1RRN2FMQ3dSOXhMY1BwK2tMcENoZGlQUHlXQStNeXBJRVNWa3ExUHBjZkduc0V5ams5R0hhZENXN2ptRERNU2xXZHR2dUtxTXFJcnpseHZKWjF0YmMwZ0xNWDRTSk5naldLL0J4VU5KdEhyczRXRjZidFQwL1NTL29qL0ttZWdaT0lFWi90bE9uZzZIUEdhckZyNGo0SVQ1elBUdVNMVVpyMEk4OWFRdUk3cElsUkx6eTcwbUNxV3FyZkFPMlpLeHFPL0J5R1RlcW9PdGQxdjZSZ1hlZFhaKzMxZTBiZCs1aU1hcExSMTlEZCtCSEd6S3BKVW1lNGZnWUNMbTk4akdJUGdZMUZVZUJMc1RDanQ1OTF0MW9VZzFYb0NocExQY3ZjbUxvZ2Y3a1FmaHlSU2dkUUdTVklFb2k1NHNXQURVU01hM0FXeWVtUnZSUkFNNjVzQXVFaVRib0NRRnkvbndhdmJRRGZQY0hxTVVhL05oNlEzWkoydGVVZHEyM1FRPT0iXSwidHlwIjoiam9zZSIsImlhdCI6MTc3OTg2ODMwOH0.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":3,"LoTEType":"http://uri.etsi.org/19602/LoTEType/EUWRPACProvidersList","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://uri.etsi.org/19602/WRPACProvidersList/StatusDetn/EU","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://uri.etsi.org/19602/WRPACProvidersList/schemerules/EU"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-27T09:51:47Z","NextUpdate":"2026-11-26T09:51:47Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse RP Access CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"1234","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.no"},{"lang":"en","uriValue":"tel:+47987654"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.no"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_no"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICuzCCAmGgAwIBAgIJAKcp7ByPxFNUMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNTA5MDc1NjU0WhcNMzAwNDI5MDc1NjU0WjBkMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxKjAoBgNVBAMTIWVpZGFzMnNhbmRrYXNzZSBSUCBBY2Nlc3MgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABE4OQr5vpRMvcYZs46LkpdDgVQ9V+9E/Gx3Io2jqm+g/43/0b2Ns9oSRv1VpY/vYSI/O6JWylRQ+MNk6V3DfQv2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUUcgCJYAwgpE7JCLUm9xeoainXcwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDSAAwRQIgfuk68h7gRHYXzBuddxFEUGl1eYtQgMCMKcw6D1kVjzgCIQC91xg+yGdocsoPmIGACivfYZAftiQXGEjHdid9RZOX1g=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Idakto"}],"TETradeName":[{"lang":"en","value":"VATFR-12345"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"1234","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.fr"},{"lang":"en","uriValue":"tel:+33234567"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.fr"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_fr"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICgjCCAiegAwIBAgIUafRAIleaQOm9jZLiIML9FeOWd9cwCgYIKoZIzj0EAwIwczELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZSQU5DRTEPMA0GA1UEBwwGQW5nZXJzMQ8wDQYDVQQKDAZJZGFrdG8xDjAMBgNVBAsMBVN0ZWFtMSEwHwYDVQQDDBhyZWFkZXItaXNzdWVyQGlkYWt0by5jb20wHhcNMjUwNzI1MTQ0NzI1WhcNMzAwNzI0MTQ0NzI1WjBzMQswCQYDVQQGEwJGUjEPMA0GA1UECAwGRlJBTkNFMQ8wDQYDVQQHDAZBbmdlcnMxDzANBgNVBAoMBklkYWt0bzEOMAwGA1UECwwFU3RlYW0xITAfBgNVBAMMGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCq6dkUsfqjCByvS+UM/FDOgjO5fbB6aEesAgWmiMrSJQybQnAGSOySr0V+E0puM3eMaLy4DzsGLW0LX6J+vRLOjgZgwgZUwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJ57lkHy09w59xHQDk4y9ubmup5VMCsGA1UdEQQkMCKCIG9wZW5pZDR2cC5kcnVrcXMuYXNnYXJkLmlkZW52LmZyMCMGA1UdEgQcMBqBGHJlYWRlci1pc3N1ZXJAaWRha3RvLmNvbTAKBggqhkjOPQQDAgNJADBGAiEA9hIBNw8GI7E5z/NZI/3CUMZjndoKGg+2o0lh8/6gY30CIQCiUgMnIib46Ypi4IryQOn282zPWrTWQFwIebwASeG9+w=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"2345","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.hu"},{"lang":"en","uriValue":"tel:+36567890"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_hu"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"A-SIT"}],"TETradeName":[{"lang":"en","value":"VATAT-45678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"2345","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.at"},{"lang":"en","uriValue":"tel:+43789012"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_wrpac_solution_at"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICJzCCAc6gAwIBAgIUSvMftn/oM3etHjE7hdIBl6tWMV8wCgYIKoZIzj0EAwIwMzELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMRQwEgYDVQQDDAtWYWxlcmEgSUFDQTAeFw0yNTA2MjYwODI0MDJaFw0yNjA2MjYwODI0MDJaMDMxCzAJBgNVBAYTAkFUMQ4wDAYDVQQKDAVBLVNJVDEUMBIGA1UEAwwLVmFsZXJhIElBQ0EwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQmm+pmyUxx/x2eD131E8HhvNkhsfYQXzefZlxgLXQPqCOxO+VPOXVOKL0dUy+kHyT5IP/NOAh038coAVOgGPT4o4G/MIG8MBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMCIGA1UdEgQbMBmGF2h0dHBzOi8vd2FsbGV0LmEtc2l0LmF0MDIGA1UdHwQrMCkwJ6AloCOGIWh0dHBzOi8vd2FsbGV0LmEtc2l0LmF0L2NybC8xLmNybDAfBgNVHSMEGDAWgBSDGoj0XuXE3qEVTmPvKSvIvR36ijAdBgNVHQ4EFgQUgxqI9F7lxN6hFU5j7ykryL0d+oowCgYIKoZIzj0EAwIDRwAwRAIgS9XcYA4Be5gDIdHmMOgJ3AeS44gT4bgVgsg/D5+WXS8CIAxJgi3nhGrVMj9SszehLorR2rR5FO5RZgITAaOIGSNP"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"WRPAC Provider - failing conformance checks"}],"TETradeName":[{"lang":"en","value":"WRPAC Provider1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"PL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wrpac@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/PL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"WRPAC Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/service/information"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"WRPAC Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration - WRPAC1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-wrpac@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/information"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/WRPACProvider/LI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"WRPAC Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDWjCCAkKgAwIBAgIQFNp7JHkUrblEFMsg3Z6PoDANBgkqhkiG9w0BAQsFADAxMRgwFgYDVQQKDA9XUlBBQyBQcm92aWRlcjExFTATBgNVBAMMDE5hbWVUZXN0Q2VydDAeFw0yNTA5MjUxNDMxMzhaFw0yNjA5MjUxNDQxMzhaMDExGDAWBgNVBAoMD1dSUEFDIFByb3ZpZGVyMTEVMBMGA1UEAwwMTmFtZVRlc3RDZXJ0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsfg1O1Eq5tt92WJRylnFc75amIjPybG3yyATDg28rF1rBOcoGFXw/Za029VlewkYCGIznE3SyoaFTcO0e14MLW4sjvSAYYIwTfKFBo7X7VwbhI+ItVrb3bgNXUeLiq5eOerfZWthjtjB5p3SjOtOmIoHpRwRvegGrlFKFK7SFGt7iGMIxKEu0FDQOi7eJnPIhaMflE7qHDfgrX8YFrc8dgi8g062nk1JWM+g+eFcj/eCyHs3adWQ/P5yEVn/A5sOeO8W3tbxA98xRkHgZbikYPaYy1tQGWzdCxZ3kehyucBysaAOuoXunWjX/v4Tx0omEkVq5Dh+lt7iH2nyU03R+QIDAQABo24wbDAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBwGA1UdEQQVMBOCEU5hbWVUZXN0Q2VydFdSUEFDMB0GA1UdDgQWBBToGtzqikCk196F3aaeq6HPxLfR3TANBgkqhkiG9w0BAQsFAAOCAQEAbqhUoauW+PRFiOO5O1QjF9pl7ncsCTL/13d4vnEmIicVOOHJjKnZ50/jGkVnPe34BaJ+iEVomNkEHg5XTaj005kTQ1Nimo9NCVJudl9v135dCPdSItGY2FRUfdesD0lYYwSEa0RUT57NeKA6ZTQNIlpE5HFywvKiktZ05GAFQuqn5UYMvaf2unEvXf6HO92yQcJ7H5A5zmJv5RBp6wFs2DznOTKdJMhjKOIybumDoXKCLQYqR9zDG042s369/UB/2FXcNfL3mi/VdayH2BwCu/OlyaxWy0pX+hhZuGEBbyrVTdJvsLSItsg7WpjxeU/GyViz227qh9xKCI/wCZmdzw=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/WRPAC/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/wrpac/service/information"}]}}]}]}}.ByL9Cs5ao-N11jGniNLsg068UlkwhfSwteGZIq5DGfog1vWtUvzZsAX4pCRUC1k44Y4KkIb0sYFbSp2FnV584yPJZ2LvEDl7QdyMRGwFSgJNTw7RpiDbrIj3ssziTMSMjh0Dm_6ZtHP8DrYKiMJI0ZrQhOstbsrym-Fxh9F1M2t-u8BwK1RnVCYxamCUfwYV_pLH_DJAQjv7sjjpL04TuKRLF1lIbyAG8xznjDWwzciQHart1gcgOwgVdK-llVFeQDAIeeO65dzlGVn5i7OJ1g0N1JRv6lVIawQGy6G-dK6Fl2yBtyg5M9MkRdDYbTXPIRff_cN8URtEneu0YCHFrtdzU5aqx52Xa-vdlUtxvAdt4FXP0L3jqtWnqHWbx5GHXDuhgWDhVljFNMXOH9tzomDwV2A900Yfi6v55aeCGD2MrUT5iVpY21a-mf-nEJLfY6jFfw6yeFpsfnXOrSIi4ah-A1i_1gT941GutwSSwbtPUQlTjSS4cONlLwTVbRH7zovIsw_XlHSViMcmyRbjq8QBPrqsQsEb9tS0XQ-c4a7JN6ayQnIES-3g2yiWxG1-bQFIQPSV46WhC_SF7M60eakDjL_QXPgkjm2xXFQ24d27GHsJS6zSxYZ0p2vMXXF42leNkHgMWWD4TgAF6-PrF4vzk0iD__f7KDCEty8dMk8" -const val MDL_PROVIDERS_JWS = "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.{"LoTE":{"ListAndSchemeInformation":{"LoTEVersionIdentifier":1,"LoTESequenceNumber":4,"LoTEType":"http://trust.ec.europa.eu/lists/mDL/mDLProvidersListType","SchemeOperatorName":[{"lang":"en","value":"European Commission"},{"lang":"bg","value":"Европейска комисия"},{"lang":"es","value":"Comisión Europea"},{"lang":"cs","value":"Evropská komise"},{"lang":"da","value":"Europa-Kommissionen"},{"lang":"de","value":"Europäische Kommission"},{"lang":"et","value":"Euroopa Komisjon"},{"lang":"el","value":"Ευρωπαϊκή Επιτροπή"},{"lang":"fr","value":"Commission européenne"},{"lang":"it","value":"Commissione europea"},{"lang":"lv","value":"Eiropas Komisija"},{"lang":"lt","value":"Europos Komisija"},{"lang":"hu","value":"Európai Bizottság"},{"lang":"mt","value":"Il-Kummissjoni Ewropea"},{"lang":"nl","value":"Europese Commissie"},{"lang":"pl","value":"Komisja Europejska"},{"lang":"pt","value":"Comissão Europeia"},{"lang":"ro","value":"Comisia Europeană"},{"lang":"sk","value":"Európska komisia"},{"lang":"sl","value":"Evropska komisija"},{"lang":"fi","value":"Euroopan komissio"},{"lang":"sv","value":"Europeiska kommissionen"},{"lang":"hr","value":"Europska komisija"}],"SchemeOperatorAddress":{"SchemeOperatorPostalAddress":[{"lang":"fr","StreetAddress":"Rue de la Loi 200","Locality":"Bruxelles","PostalCode":"1049","Country":"BE"},{"lang":"nl","StreetAddress":"Wetstraat 200","Locality":"Brussel","PostalCode":"1049","Country":"BE"},{"lang":"en","StreetAddress":"Rue de la Loi/Wetstraat 200","Locality":"Brussels","PostalCode":"1049","Country":"BE"}],"SchemeOperatorElectronicAddress":[{"lang":"en","uriValue":"mailto:DIGIT-EU-TRUST-NON-PROD@ec.europa.eu"},{"lang":"en","uriValue":"https://digital-strategy.ec.europa.eu/en/policies/eu-trusted-lists"}]},"SchemeName":[{"lang":"en","value":"The present list is a list of person identifier providers of EUDI Wallet issued in accordance with CIR 2024/2980"}],"SchemeInformationURI":[{"lang":"en","uriValue":"https://trust.tech.ec.europa.eu/lists/eudiw/mdl-providers-list-scheme-information"}],"StatusDeterminationApproach":"http://trust.ec.europa.eu/lists/mDL/mDLProvidersListStatusDetn","SchemeTypeCommunityRules":[{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/schemerules"}],"SchemeTerritory":"EU","PolicyOrLegalNotice":[{"LoTEPolicy":{"lang":"en","uriValue":"http://trust.tech.ec.europa.eu/lists/eudiw/legal-notice#EN"}}],"ListIssueDateTime":"2026-05-28T10:53:35Z","NextUpdate":"2026-11-27T10:53:35Z"},"TrustedEntitiesList":[{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Agence Nationale des Titres Sécurisés"}],"TETradeName":[{"lang":"en","value":"VATFR-2356568"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"3465","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.fr"},{"lang":"en","uriValue":"tel:+337848346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.fr"},{"lang":"en","uriValue":"http://uri.etsi.org/19602/ListOfTrustedEntities/mDLProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDLTCCAtKgAwIBAgISESEFJUbpBJovlg7lg3Eb5YTCMAoGCCqGSM49BAMCMIGiMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE8MDoGA1UEAwwzQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIEF0dGVzdGF0aW9ucyBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgaIxCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTwwOgYDVQQDDDNBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAASa4ZI0w4Mn4FW6kYdKPUlYYgVbwFf1A6lBDnurRsoPJxM3+dVupbkGl9O+QnJ36wc8ngoXE3oH1hP11flDmWsIo4HlMIHiMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMDAGA1UdEgQpMCeBJWZyYW5jZS1hdHRlc3RhdGlvbnNAaW50ZXJpZXVyLmdvdXYuZnIwSgYDVR0fBEMwQTA/oD2gO4Y5aHR0cDovL2NybC5hbnRzLmdvdXYuZnIvYWNfZnJhbmNlX2F0dGVzdGF0aW9uc19pYWNhXzEuY3JsMB0GA1UdDgQWBBT/dscZoX+tou0+F2dDsFrTPfsMpzAfBgNVHSMEGDAWgBT/dscZoX+tou0+F2dDsFrTPfsMpzAKBggqhkjOPQQDAgNJADBGAiEAmMD8Kpgnctmx12gCBYrj98knoKDSPlO5SucThy1EEqwCIQDsYM80Ere4Yw0fHNJQQHl6D1rAITDV3qFKP62Uq7xtsQ=="}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}},{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDUzCCAvmgAwIBAgISESHtNjf+2KAQ0ttWtR9EhAAPMAoGCCqGSM49BAMCMIHFMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjEmMCQGA1UECwwdUE9VUiBRVUFMSUZJQ0FUSU9OIFVOSVFVRU1FTlQxNzA1BgNVBAMMLkF1dG9yaXTDqSBkZSBDZXJ0aWZpY2F0aW9uIEZyYW5jZSBBdHRlc3RhdGlvbnMxCjAIBgNVBAUTATEwHhcNMjUwMTI5MDAwMDAwWhcNMzAwMTI5MDAwMDAwWjCBxTELMAkGA1UEBhMCRlIxMDAuBgNVBAoMJ0FnZW5jZSBOYXRpb25hbGUgZGVzIFRpdHJlcyBTw6ljdXJpc8OpczEXMBUGA1UECwwOMDAwMiAxMzAwMDMyNjIxJjAkBgNVBAsMHVBPVVIgUVVBTElGSUNBVElPTiBVTklRVUVNRU5UMTcwNQYDVQQDDC5BdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgQXR0ZXN0YXRpb25zMQowCAYDVQQFEwExMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEoCYCM9LYS8zUk8I1xL2B2G9voa4yFskoqohrsEQkpNEeKb59J3VDHausTqFWCOfwEGUzi6yocLIbE+gfz59pnaOBxjCBwzAOBgNVHQ8BAf8EBAMCAQYwMAYDVR0SBCkwJ4ElZnJhbmNlLWF0dGVzdGF0aW9uc0BpbnRlcmlldXIuZ291di5mcjASBgNVHRMBAf8ECDAGAQH/AgEAMEwGA1UdHwRFMEMwQaA/oD2GO2h0dHA6Ly9jcmwucXVhbGlmLmFudHMuZ291di5mci9hY19mcmFuY2VfYXR0ZXN0YXRpb25zXzEuY3JsMB0GA1UdDgQWBBR3bIy6PB3fPAlYHOvqk7nftps4sDAKBggqhkjOPQQDAgNIADBFAiBrI2HGG1SZNRfEoaIwk3bjAjLBcE9tcKPi1gu0oah58AIhAL+KWRF8FwT4JBblyZdmuoVVXJ36LMmAUcs5YwJpMiQW"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}},{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fr_3"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDHTCCAsSgAwIBAgISESEhmoph1P1OOjDCLJAgGdBbMAoGCCqGSM49BAMCMIGfMQswCQYDVQQGEwJGUjEwMC4GA1UECgwnQWdlbmNlIE5hdGlvbmFsZSBkZXMgVGl0cmVzIFPDqWN1cmlzw6lzMRcwFQYDVQQLDA4wMDAyIDEzMDAwMzI2MjE5MDcGA1UEAwwwQXV0b3JpdMOpIGRlIENlcnRpZmljYXRpb24gRnJhbmNlIElkZW50aXTDqSBJQUNBMQowCAYDVQQFEwExMB4XDTI1MTAxNzAwMDAwMFoXDTM0MTAxNzAwMDAwMFowgZ8xCzAJBgNVBAYTAkZSMTAwLgYDVQQKDCdBZ2VuY2UgTmF0aW9uYWxlIGRlcyBUaXRyZXMgU8OpY3VyaXPDqXMxFzAVBgNVBAsMDjAwMDIgMTMwMDAzMjYyMTkwNwYDVQQDDDBBdXRvcml0w6kgZGUgQ2VydGlmaWNhdGlvbiBGcmFuY2UgSWRlbnRpdMOpIElBQ0ExCjAIBgNVBAUTATEwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQqfRW/7OTJS4K0IPMa/c8UicIUq62jTccQtGnHAYk6UnvXyRO3PC4/2pdq5QjhwIKwJVqCFOr4fbGboMKLX+L/o4HdMIHaMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMCwGA1UdEgQlMCOBIWZyYW5jZS1pZGVudGl0ZUBpbnRlcmlldXIuZ291di5mcjBGBgNVHR8EPzA9MDugOaA3hjVodHRwOi8vY3JsLmFudHMuZ291di5mci9hY19mcmFuY2VfaWRlbnRpdGVfaWFjYV8xLmNybDAdBgNVHQ4EFgQUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wHwYDVR0jBBgwFoAUAQ1+Rjq9mU0kAyKKyTwFdgjmwA4wCgYIKoZIzj0EAwIDRwAwRAIgSNKCT8z4zaZLfdOd/rHevKYDbvjqylK723wjd4g4s0ECIDnoWVWyJHwlO31z3QmK7QapM00sOCJnsTIvEGi1Fz/I"}]},"ServiceTypeIdentifier":"http://uri.etsi.org/19602/SvcType/mDL/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digitaliseringsdirektoratet - Bevisporten"}],"TETradeName":[{"lang":"en","value":"NTRNO-NOFOR.991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"5788","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+4734869323"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDBTCCAqygAwIBAgIJALyA/nuVMsUpMAoGCCqGSM49BAMEMIGCMR4wHAYDVQRhExVOVFJOTy1OT0ZPUi45OTE4MjU4MjcxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBFQUEgUHJvdmlkZXIgQ0EgdGVzdDEkMCIGA1UEChMbRElHSVRBTElTRVJJTkdTRElSRUtUT1JBVEVUMQswCQYDVQQGEwJOTzAeFw0yNTEwMTAwODE2MzZaFw0yNjEwMDgxMjQ3MzZaMGExCzAJBgNVBAYTAk5PMTIwMAYDVQQDDClEaWdpdGFsaXNlcmluZ3NkaXJla3RvcmF0ZXQgLSBCZXZpc3BvcnRlbjEeMBwGA1UEYQwVTlRSTk8tTk9GT1IuOTkxODI1ODI3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEggybfUUfbzJltJnTd3NjkH/OApRXdjznhsiDEShxa14362U8s1d/z8fsFMNxiO+z/ZSkHsUurkh2EiNQMcG0T6OCASkwggElMB8GA1UdIwQYMBaAFG2uFOu+dBM1aEzXwQ1nMTFpj7JfMB0GA1UdDgQWBBRTpQH9HAw203fM8Z6Nnc6Aj5RsVzAMBgNVHRMBAf8EAjAAMFwGA1UdHwRVMFMwUaBPoE2GS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNybDBnBggrBgEFBQcBAQRbMFkwVwYIKwYBBQUHMAKGS2h0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL2ludGVybWVkaWF0ZXMvZWFhX3Byb3ZpZGVyLmNlcjAOBgNVHQ8BAf8EBAMCBaAwCgYIKoZIzj0EAwQDRwAwRAIgco5xnaAZPzLFF0aC7FbF3bEmbHsXId42CRiZIJdqyK0CIG9cjXM31kTF3kmHgN8NligxMbxEmT2HjkAYkKRKUUZR"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digitaliseringsdirektoratet - mDL-utsteder"}],"TETradeName":[{"lang":"en","value":"NTRNO-NOFOR.991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"3478","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+47348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDMzCCAtmgAwIBAgIIGkwIqxyvEDswCgYIKoZIzj0EAwQwZzEYMBYGA1UEYRMPTlRSTk8tOTkxODI1ODI3MQswCQYDVQQGEwJubzEPMA0GA1UECxMGRGlnZGlyMS0wKwYDVQQDEyRlaWRhczJzYW5ka2Fzc2UgUElEIFByb3ZpZGVyIENBIHRlc3QwHhcNMjUxMDE1MTExMzA3WhcNMjYxMDE1MTExMzA3WjBiMQswCQYDVQQGEwJOTzEzMDEGA1UEAwwqRGlnaXRhbGlzZXJpbmdzZGlyZWt0b3JhdGV0IC0gUElELXV0c3RlZGVyMR4wHAYDVQRhDBVOVFJOTy1OT0ZPUi45OTE4MjU4MjcwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATLIEmdVcdTVfQ/6YpsPvS4taSRiebXwcjHWGEWpZLfrKb3yvowmUMe2SaDZD8HCOXjvSXfbIQsgFKeMU88IkNaDOfyMHbXYf3cJZCFJYo799hQL6j2tMogjUMkyoP+dnCjggFVMIIBUTAfBgNVHSMEGDAWgBRX7XviJqjDMVi/g0bAr0FvQshSDDAdBgNVHQ4EFgQUUCIS5a/pLXMjHV+a4AV8NkiRHZMwDAYDVR0TAQH/BAIwADBcBgNVHR8EVTBTMFGgT6BNhktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jcmwwZwYIKwYBBQUHAQEEWzBZMFcGCCsGAQUFBzAChktodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9pbnRlcm1lZGlhdGVzL3BpZF9wcm92aWRlci5jZXIwDgYDVR0PAQH/BAQDAgWgMCoGCCsGAQUFBwEDAQH/BBswGQYGBACORgEGDA9pZC1ldHNpLXFjdC1waWQwCgYIKoZIzj0EAwQDSAAwRQIgPNu17SJ+E628cVBT1J1CCZQEI85MIG1hqm1ynwyQN84CIQC67g+mvEDLF9C5gcwN8Q38IEJu3bw0EhCvBbUqPORQPA=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Digi- ja väestötietovirasto"}],"TETradeName":[{"lang":"en","value":"VATFI-8567"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"5685","Country":"FI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.fi"},{"lang":"en","uriValue":"tel:+358348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.fi"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/FI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_fi"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDDTCCApKgAwIBAgIUaqDAxDTFQMkDVdM0LpPFNCskEV4wCgYIKoZIzj0EAwMwgagxODA2BgNVBAMML0RWViBEaWdpLUlEIE1vY2sgQXR0cmlidXRlIFNlYWxpbmcgQ2VydGlmaWNhdGVzMSYwJAYDVQQKDB1EaWdpLSBqYSB2w6Rlc3TDtnRpZXRvdmlyYXN0bzERMA8GA1UEBwwISGVsc2lua2kxCzAJBgNVBAYTAkZJMRAwDgYDVQQIDAdGaW5sYW5kMRIwEAYDVQQFEwkwMjQ1NDM3LTIwHhcNMjQwMTE1MDkyNTE5WhcNMzMwMTEyMDkyNTE5WjCBqDE4MDYGA1UEAwwvRFZWIERpZ2ktSUQgTW9jayBBdHRyaWJ1dGUgU2VhbGluZyBDZXJ0aWZpY2F0ZXMxJjAkBgNVBAoMHURpZ2ktIGphIHbDpGVzdMO2dGlldG92aXJhc3RvMREwDwYDVQQHDAhIZWxzaW5raTELMAkGA1UEBhMCRkkxEDAOBgNVBAgMB0ZpbmxhbmQxEjAQBgNVBAUTCTAyNDU0MzctMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABGcz86+Pt3o1TZ5BYKXtOrFhqi6fDVq7+32J8DaeiSibJES5c9mAPIP/eNB8b+Wm+7RU9blUZ3xlxsmVTGScEOwwSVczmiwBHtk4+7KNltd6CrAAFgSdyDKCEe+w+AKwLqN7MHkwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwGQYDVR0SBBIwEIYOaHR0cHM6Ly9kdnYuZmkwGQYDVR0RBBIwEIYOaHR0cHM6Ly9kdnYuZmkwHQYDVR0OBBYEFJNVLFsDRkyYNcoRYUEBvtvpEOv7MAoGCCqGSM49BAMDA2kAMGYCMQCwfwzQ2A07a3RiA3BUs2BhdNNuhiZcj5HZN7H8fEEiSvkHay67c2XvuyRlZ+zhE18CMQD6OMM6GM+7oKSBtHEbXuiskiWhl9nq7FPQDwPFoaVGxu/SQ3itFL4k2nNsJrEBcfg="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse mDL Provider CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"4332","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+47348346754"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_3"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICvTCCAmSgAwIBAgIJAJ7Fdm0r3xiMMAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDE5WhcNMjkxMjE2MDk1MDE5WjBnMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxLTArBgNVBAMTJGVpZGFzMnNhbmRrYXNzZSBQSUQgUHJvdmlkZXIgQ0EgdGVzdDBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABMyVKdaQbLy6E4y7A2Crz/7qBv2x9vebD+7B3N0o2rpxXsDzOQYkBBaBh8uD2LxmEI3E3a6vISekCY0NK/nhUR2jgfwwgfkwUQYIKwYBBQUHAQEERTBDMEEGCCsGAQUFBzAChjVodHRwczovL2NhLnRlc3QuZWlkYXMyc2FuZGthc3NlLm5ldC92MS9jZXJ0cy9yb290LmNlcjAdBgNVHQ4EFgQUV+174iaowzFYv4NGwK9Bb0LIUgwwDgYDVR0PAQH/BAQDAgEGMAwGA1UdEwQFMAMBAf8wRgYDVR0fBD8wPTA7oDmgN4Y1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jcmwwHwYDVR0jBBgwFoAUCi/G/x9Z1uJAVlFqD3onNXclrPEwCgYIKoZIzj0EAwMDRwAwRAIgLvJLEoUbacsoa2calE0f/XVOAnHDWVYDizHJqJAwS3kCIDz8miu6b8cD09rfGSD727joqPunkIGRQqi72HTVabcA"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"eidas2sandkasse Pub EAA Provider CA test"}],"TETradeName":[{"lang":"en","value":"NTRNO-991825827"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"test","Locality":"test","StateOrProvince":"test","PostalCode":"test","Country":"NO"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@test.no"},{"lang":"en","uriValue":"tel:+4734869323"}]},"TEInformationURI":[{"lang":"en","uriValue":"http://test.no"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/NO"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mDL_solution_no_4"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICwjCCAmigAwIBAgIJAPm2yYm712+4MAoGCCqGSM49BAMDMGMxGDAWBgNVBGETD05UUk5PLTk5MTgyNTgyNzELMAkGA1UEBhMCbm8xDzANBgNVBAsTBkRpZ2RpcjEpMCcGA1UEAxMgZWlkYXMyc2FuZGthc3NlLm5ldCByb290IENBIHRlc3QwHhcNMjUwNzE0MDk1MDUxWhcNMjkxMjE2MDk1MDUxWjBrMRgwFgYDVQRhEw9OVFJOTy05OTE4MjU4MjcxCzAJBgNVBAYTAm5vMQ8wDQYDVQQLEwZEaWdkaXIxMTAvBgNVBAMTKGVpZGFzMnNhbmRrYXNzZSBQdWIgRUFBIFByb3ZpZGVyIENBIHRlc3QwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS+7CQFU3oWwu9dxauSvk5Xc7AeDhDtLb/x8WcUWFvlG4ekHKlqvW9gxe+W4KJrfn95UZ/0fOfm+znsha/zpiMKo4H8MIH5MFEGCCsGAQUFBwEBBEUwQzBBBggrBgEFBQcwAoY1aHR0cHM6Ly9jYS50ZXN0LmVpZGFzMnNhbmRrYXNzZS5uZXQvdjEvY2VydHMvcm9vdC5jZXIwHQYDVR0OBBYEFD/oYNwZ6+S0FLt9IQvCHPFK6ktiMA4GA1UdDwEB/wQEAwIBBjAMBgNVHRMEBTADAQH/MEYGA1UdHwQ/MD0wO6A5oDeGNWh0dHBzOi8vY2EudGVzdC5laWRhczJzYW5ka2Fzc2UubmV0L3YxL2NlcnRzL3Jvb3QuY3JsMB8GA1UdIwQYMBaAFAovxv8fWdbiQFZRag96JzV3JazxMAoGCCqGSM49BAMDA0gAMEUCIHcgPyDKaizjJPpyztDqUwVqDabzOBVSQwgFIAFT+aV+AiEA8sFi8APxqLmwmCjd5EOd2WhGXSWRksIcCW+aS8kpPmU="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"AMA - Agência para a Modernização Administrativa"}],"TETradeName":[{"lang":"en","value":"VATPT-27373"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23451","Country":"PT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.pt"},{"lang":"en","uriValue":"tel:+35198765"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.pt"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/PT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_pt"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIC3zCCAoWgAwIBAgIUcSydOyasuB5uNjr9rj5tPAhpbQUwCgYIKoZIzj0EAwIwejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMB4XDTI0MDgyMzE4MTQ0N1oXDTMzMTExOTE4MTQ0NlowejEtMCsGA1UEAwwkRW1pc3NvciBkZSBQSUQgLSBDZXJ0aWZpY2FkbyByYWl6IDAxMTwwOgYDVQQKDDNBTUEgLSBBZ8OqbmNpYSBwYXJhIGEgTW9kZXJuaXphw6fDo28gQWRtaW5pc3RyYXRpdmExCzAJBgNVBAYTAlBUMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEJQQp1ekgl4ztbyvAEHQcHjiIwNRbELpVBzqXiGP2AZdhCP0qgEQ5Ud2hb0fbrE2/hEtiZmw0ppGX37g/wx+VLaOB6DCB5TASBgNVHRMBAf8ECDAGAQH/AgEAMB8GA1UdIwQYMBaAFNl5BlM1kkgig634oJOTlZRNJbezMBYGA1UdJQEB/wQMMAoGCCuBAgIAAAEHMEMGA1UdHwQ8MDowOKA2oDSGMmh0dHBzOi8vcHJlcHJvZC5wa2kuYW1hLnByb2pqLmV1L2NybC9waWRfQ0FfMDEuY3JsMB0GA1UdDgQWBBTZeQZTNZJIIoOt+KCTk5WUTSW3szAOBgNVHQ8BAf8EBAMCAQYwIgYDVR0SBBswVIZSaHR0cHM6Ly93d3cuYW1hLmdvdi5wdC8wCgYIKoZIzj0EAwIDSAAwRQIhAPlr1TTIv8pTKOY08FpKrpNsFLj9gKIagDIUHcDPjy6iAiBL8GUS5H5NcHhTEjJxxEMX9CVuFfVhvRCssbaCV3RwsA=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"A-SIT"}],"TETradeName":[{"lang":"en","value":"VATAT-37373"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23451","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.at"},{"lang":"en","uriValue":"tel:+4398279"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_at_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICGzCCAcCgAwIBAgIUb9GJdqQMdwXaoO61uxoBlg+jhbYwCgYIKoZIzj0EAwIwLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMB4XDTI1MDQwNzA5NDQ1N1oXDTI2MDQwNzA5NDQ1N1owLDELMAkGA1UEBhMCQVQxDjAMBgNVBAoMBUEtU0lUMQ0wCwYDVQQDDARJQUNBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElIXOzb+iF+zGutygdIVOBnC4R6OvhYo5TGWhrH0idmqs56IVwJWYzQYzK4CbYePcxpMQY3lKBa5O0MAZe+EogKOBvzCBvDASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBBjAiBgNVHRIEGzAZhhdodHRwczovL3dhbGxldC5hLXNpdC5hdDAyBgNVHR8EKzApMCegJaAjhiFodHRwczovL3dhbGxldC5hLXNpdC5hdC9jcmwvMS5jcmwwHwYDVR0jBBgwFoAUDQF5K46YVgzLpfV5stoutBezK6QwHQYDVR0OBBYEFA0BeSuOmFYMy6X1ebLaLrQXsyukMAoGCCqGSM49BAMCA0kAMEYCIQCz0i9GA24ZOf3Wk+w8+09J6ARAHKLuBuepszBxVZdaZAIhAJlgzKBhHw8+Bwr+wLGQVjMC5e9BWWaUga8ZP9dRYhHJ"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"IDAKTO IACA 4"}],"TETradeName":[{"lang":"en","value":"VATFR-73829"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"23343","Country":"FR"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test@domain.fr"},{"lang":"en","uriValue":"tel:+33857302"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.fr"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/FR"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_fr_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIB2TCCAX+gAwIBAgIJAI5LEB+QbO+3MAoGCCqGSM49BAMCMCUxCzAJBgNVBAYTAkZSMRYwFAYDVQQDDA1JREFLVE8gSUFDQSA0MB4XDTI0MDkyNjEyMzQ1M1oXDTI5MDkyNTEyMzQ1M1owJTELMAkGA1UEBhMCRlIxFjAUBgNVBAMMDUlEQUtUTyBJQUNBIDQwWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARMophaPOvIcnsKuxs3iGxJA3kyQx3pHeC0LWj8RNPLtYWAcPJq8bB5PSyOkGtB6XcGUTJukaBxU//5cAe2I18po4GXMIGUMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS2EQayXDKCQSR99d/ve3ZXwxWPpzAaBgNVHRIEEzARgQ9pYWNhQGlkYWt0by5jb20wMwYDVR0fBCwwKjAooCagJIYiaHR0cDovL2NybC5jaG9wcGVyLmlkbGFiLmxpdmU6NTU1NTAKBggqhkjOPQQDAgNIADBFAiAX1wM1La0uufb2yA4jZ+11FfF6hcx3ER8/kcC52teviQIhALNwfW4Zusu4QD8QFxRKrLyi8UVWpDXI5G7rHRnIbNPf"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"ISO Root CA"}],"TETradeName":[{"lang":"en","value":"VATAT-90021"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"63823","Country":"AT"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.at"},{"lang":"en","uriValue":"tel:+33848209"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/AT"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_at_2"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICbDCCAhKgAwIBAgIUH23VY4YX6sFgbdidaIr2o7cR154wCgYIKoZIzj0EAwIwIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMB4XDTI1MDUyODExNTMxMloXDTM1MDUyNjExNTMxMlowIzELMAkGA1UEBhMCQVQxFDASBgNVBAMMC0lTTyBSb290IENBMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEisG5+9ei6IRPnTkc2HuiY5kDWM+SUEeTkDXBs7bz/Xc1gwa0WbfEwJA2GuasCl4h0Zzv2fuDK+ER2+Gb7IsPWKOCASIwggEeMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTeJAquS8H45Kv/lng41lul7kTOCDAfBgNVHSMEGDAWgBTeJAquS8H45Kv/lng41lul7kTOCDCBiwYDVR0fBIGDMIGAMH6gfKB6hnhodHRwczovL3ZhdWx0LmxpZS1pbnRlcm5hbC5wcm9kdWN0aW9uLmNsdXN0ZXJzLnlvdW5pcXguY29tL3YxL21hbmFnZWQvcGtpL21pYS1saWUtaW50ZXJuYWwvbWlhLWxpZS1pbnRlcm5hbC1pc28tcm9vdC9jcmwwKgYDVR0SBCMwIYEfdGVhbS5xdWFudHVtcXVva2thc0B5b3VuaXF4LmNvbTAKBggqhkjOPQQDAgNIADBFAiA9ehNPI3Ck4bfcma27BbKClYLOmjIbu0ytFf6etfp5dwIhAIZT1olmq8bVm7iDRjtFAWUUpNjKQMPAXXY83EbqiqQV"}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Bundesdruckerei GmbH"}],"TETradeName":[{"lang":"en","value":"VATDE-82718"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"638382","Country":"DE"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.de"},{"lang":"en","uriValue":"tel:+4971501"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.at"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/DE"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_de_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICNTCCAdygAwIBAgIUBEfh5TdWaKkeiOkVBHKBHe7VHOUwCgYIKoZIzj0EAwIwZzELMAkGA1UEBhMCREUxDzANBgNVBAcMBkJlcmxpbjEdMBsGA1UECgwUQnVuZGVzZHJ1Y2tlcmVpIEdtYkgxETAPBgNVBAsMCFQgQ1MgSURFMRUwEwYDVQQDDAxQSURQIERlbW8gQ0EwHhcNMjUxMTE5MTIwNjMwWhcNMzUxMTE3MTIwNjMwWjBnMQswCQYDVQQGEwJERTEPMA0GA1UEBwwGQmVybGluMR0wGwYDVQQKDBRCdW5kZXNkcnVja2VyZWkgR21iSDERMA8GA1UECwwIVCBDUyBJREUxFTATBgNVBAMMDFBJRFAgRGVtbyBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABLfzEvVnrtzbM47MtwES2H4cOFtqvaZEQw4DGMiENSbfKih9WxxhDN8HzuukmiFZYhOxy0frbPlCBJkhGZFsKOWjZjBkMB0GA1UdDgQWBBSAX87IYWUcmGz01ZRdX/qAWEO+XzAfBgNVHSMEGDAWgBSAX87IYWUcmGz01ZRdX/qAWEO+XzASBgNVHRMBAf8ECDAGAQH/AgEAMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAgNHADBEAiBae8hSEdl3gqo8gmbvl9IV9rTrG5iw/6kk6h8w0upuVwIgM29abFnlKUY07mil1xc43zoMqql4YuWv29VHA9ZiT4Y="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"Microsec Ltd."}],"TETradeName":[{"lang":"en","value":"VATHU-23584497"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"73824","Country":"HU"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.hu"},{"lang":"en","uriValue":"tel:+36019283"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.hu"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/HU"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_hu_1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDQzCCAuigAwIBAgIMBcKMJXgy2272WHQKMAoGCCqGSM49BAMCMHYxCzAJBgNVBAYTAkhVMREwDwYDVQQHDAhCdWRhcGVzdDEWMBQGA1UECgwNTWljcm9zZWMgTHRkLjEXMBUGA1UEYQwOVkFUSFUtMjM1ODQ0OTcxIzAhBgNVBAMMGlRlc3QgZS1Temlnbm8gUm9vdCBDQSAyMDE3MB4XDTE3MDkyMjIwMDAwMFoXDTQyMDkyMjA2MDAwMFowcTELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRYwFAYDVQQKDA1NaWNyb3NlYyBMdGQuMRcwFQYDVQRhDA5WQVRIVS0yMzU4NDQ5NzEeMBwGA1UEAwwVVGVzdCBlLVN6aWdubyBDQSAyMDE3MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAElKYzOPtAdd2ohSfwEgX2A+Zr2jXWrEqAwJYRs9aBjxT67VwuD10R+TEY0aRwzbrAAPfR2hsOr9DcvZlh4AXRraOCAV8wggFbMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vdGVzenQuZS1zemlnbm8uaHUvcWNwczAdBgNVHQ4EFgQUeptoh454hhbzt/k2HvgamLNkHIkwHwYDVR0jBBgwFoAUklDZBPHkz7JSHyQKgYTiOO2dO44wOQYDVR0fBDIwMDAuoCygKoYoaHR0cDovL3Rlc3p0LmUtc3ppZ25vLmh1L3Ryb290Y2EyMDE3LmNybDB9BggrBgEFBQcBAQRxMG8wNwYIKwYBBQUHMAGGK2h0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90ZXN0cm9vdGNhMjAxN29jc3AwNAYIKwYBBQUHMAKGKGh0dHA6Ly90ZXN6dC5lLXN6aWduby5odS90cm9vdGNhMjAxNy5jcnQwCgYIKoZIzj0EAwIDSQAwRgIhAL+F7BHEDUvV/weTnf4TwzwDIssl0hMF/0oKo0c9CaXXAiEAvNpfSAJjlU9kCqsRVUYVQqVffJCuBPIKdFvfcejwfbY="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"TEST Authority"}],"TETradeName":[{"lang":"en","value":"VATEE-373091"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"53242","Country":"EE"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.ee"},{"lang":"en","uriValue":"tel:+372932394"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.ee"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/EE"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_ee"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICiTCCAjCgAwIBAgIUD89WCelKX+PFzZTKvrIsMgoIjZcwCgYIKoZIzj0EAwIwUjELMAkGA1UEBhMCRUUxDjAMBgNVBAgMBUhhcmp1MRcwFQYDVQQKDA5URVNUIEF1dGhvcml0eTEaMBgGA1UEAwwRVEVTVCBJQUNBIFJvb3QgQ0EwHhcNMjUwMjE5MTExNDI2WhcNNDUwMjE0MTExNDI2WjBSMQswCQYDVQQGEwJFRTEOMAwGA1UECAwFSGFyanUxFzAVBgNVBAoMDlRFU1QgQXV0aG9yaXR5MRowGAYDVQQDDBFURVNUIElBQ0EgUm9vdCBDQTBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABOJyw8+GgiTyqkzhvwA5nNMwsjLA24/2wjYrXJMb23fCAWeskZu014znoXZHJZK+cxlnvLtLscYCiF7REr6NWcqjgeMwgeAwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHAddh/lzBAlZm1hAO/QgQmhV9WBMCMGA1UdEgQcMBqBGGNvbnRhY3RAaWFjYS5leGFtcGxlLmNvbTB2BgNVHR8EbzBtMGugaaBnhmVodHRwczovL3Jhdy5naXRodWJ1c2VyY29udGVudC5jb20vb3Blbi1laWQvZXVkaS1xZWFhLWlzc3Vlci1wb2MvcmVmcy9oZWFkcy9kZXZlbG9wL2xvY2FsL2NybC9pYWNhLmNybDAKBggqhkjOPQQDAgNHADBEAiBt84QP49zoXBFItKhxIPkg+7qXbf6eIMY0xkc1M7RYlQIgWOSUJbP8KEreKUQ5Nwgae13YifG3jpJfU+nVWAe+1Ik="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"GRNET"}],"TETradeName":[{"lang":"en","value":"VATEL-7283"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Rue test","Locality":"test","StateOrProvince":"test","PostalCode":"53242","Country":"EL"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:test2@domain.el"},{"lang":"en","uriValue":"tel:+302932394"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://test.el"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/EL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"name_mdl_solution_el"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIICkTCCAjigAwIBAgIUBHi4ixVY+v67hn64ELqWc/cuIoQwCgYIKoZIzj0EAwIwPTEeMBwGA1UEAwwVUElEIElzc3VlciBDQSAtIEdSIDAxMQ4wDAYDVQQKDAVHUk5FVDELMAkGA1UEBhMCR1IwHhcNMjUxMTAzMTMwMzQ1WhcNMjYxMTAzMTMwMzQ1WjA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUjBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABGV76duOyXnqudRE1nzJHu4TF/hQLSzrUNNj/g14e1eno+mdF/2BUsTKMMoVi6Nvahco45gI0aC/sXBK+zfhysmjggEUMIIBEDASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQ9fVq9ZifBrdIV1gL89UMxFC+HyzBiBgNVHSMEWzBZoUGkPzA9MR4wHAYDVQQDDBVQSUQgSXNzdWVyIENBIC0gR1IgMDExDjAMBgNVBAoMBUdSTkVUMQswCQYDVQQGEwJHUoIUBHi4ixVY+v67hn64ELqWc/cuIoQwFgYDVR0lAQH/BAwwCgYIK4ECAgAAAQcwMgYDVR0fBCswKTAnoCWgI4YhaHR0cDovLzgzLjIxMi43Mi4xMTQ6ODA4Mi9jcmwucGVtMA4GA1UdDwEB/wQEAwIBBjAbBgNVHRIEFDAShhBodHRwczovL2dybmV0LmdyMAoGCCqGSM49BAMCA0cAMEQCICAFSFanRww3RVPLqp4IC+/1JxXF9q3qE22t0R0pSKxUAiAJLUpXIknyy2qAwukAZujeuZne71PJ1Yh9xYjUdQZuhQ=="}]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance"}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"mDL Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration1"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-mdl@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl/information"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/LI"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"mDL Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}],"X509SKIs":["0RI/MTHeLnYjg8CQlPsrBXvWZLk="]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/service/information"}]}}]},{"TrustedEntityInformation":{"TEName":[{"lang":"en","value":"mDL Provider1"}],"TETradeName":[{"lang":"en","value":"Liechtenstein National Administration"},{"lang":"en","value":"VATLI-2345678"}],"TEAddress":{"TEPostalAddress":[{"lang":"en","StreetAddress":"Platz 2","Locality":"Vaduz","StateOrProvince":"Liechtenstein","PostalCode":"Fl-001","Country":"LI"}],"TEElectronicAddress":[{"lang":"en","uriValue":"mailto:office-mdl@test.li"},{"lang":"en","uriValue":"tel:+423887744"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl"}]},"TEInformationURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/policies"},{"lang":"en","uriValue":"https://www.llv.li/en/mdl/information"},{"lang":"en","uriValue":"http://trust.ec.europa.eu/lists/mDL/mDLProvider/PL"}]},"TrustedEntityServices":[{"ServiceInformation":{"ServiceName":[{"lang":"en","value":"mDL Service 1"}],"ServiceDigitalIdentity":{"X509Certificates":[{"val":"MIIDsjCCApqgAwIBAgIQa5/PTwD9epxBQHrl6XObezANBgkqhkiG9w0BAQsFADBsMQswCQYDVQQGEwJMSTEOMAwGA1UEBwwFVmFkdXoxDDAKBgNVBAsMA0xMVjEuMCwGA1UECgwlTGllY2h0ZW5zdGVpbiBOYXRpb25hbCBBZG1pbmlzdHJhdGlvbjEPMA0GA1UEAwwGbGx2LmxpMB4XDTI2MDEwNTEzMTkyMFoXDTI3MDEwNTEzMTk1MFowbDELMAkGA1UEBhMCTEkxDjAMBgNVBAcMBVZhZHV6MQwwCgYDVQQLDANMTFYxLjAsBgNVBAoMJUxpZWNodGVuc3RlaW4gTmF0aW9uYWwgQWRtaW5pc3RyYXRpb24xDzANBgNVBAMMBmxsdi5saTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJtDK/L1QEAj7QNtAgA5SNVXXahMtwayCAHtimJEGMRXeiI9KSE+BBfQ8c989Wbw9KqLsIUWGNuleGQCRFWArZmWXXezHn3fJecpeb06t+OZiPaLgq4iBp8EZ0czGFIxNxXOtSSgVcL1FCsDnIW9yzRt/xFPUn/59F6oGky/KPQXg0sW3UOkTW/k795QqIvLaMPFKn1kKkBSGh4TWmp6zQ0c7lEWGLKlCV0l0XHQAwl0bmoebEsA7QBG320i31n4Gr5y0zCbWjxEv3IU6RWZ2QARlybj4lVXyTyiezJ91v2tEhWlE/xK6AV7y9N5IcB5e+sxKDmjCp4gb1idBJYM9W0CAwEAAaNQME4wDgYDVR0PAQH/BAQDAgWgMB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATAdBgNVHQ4EFgQU0RI/MTHeLnYjg8CQlPsrBXvWZLkwDQYJKoZIhvcNAQELBQADggEBAHlLN3fEK8q9mk5Uy6Y0Bnq7clLKAlajbUcPc2/SAiYsmioNv5k6p6dAiNXng4gaSe1gGQz9o15raYz2EK3nfmw1ooFjXjmZOfiY2EBsBd9X3EJCu2aYBDeOaX3Xqw1s0ZXdfmDnvqEEmVvVr+VubzX8JLS2AM2glyRvBb7w27gBBvptggS54P9Re16yGxiQbqV17k8h/0idYbGH31Y8lUYRyOHkFtlL4pqJmCQ38laej0L73GiUtCg0hdrGcrEf2oziO55pBpsJTAiiCkv/Pz7Ri4o8l3ALQKrByloO2mpwlPmVmxxNi/o79XFGelTIBrWIVYgBbTwfDzvQIIKjY6I="}],"X509SKIs":["0RI/MTHeLnYjg8CQlPsrBXvWZLk="]},"ServiceTypeIdentifier":"http://trust.ec.europa.eu/lists/mDL/SvcType/Issuance","ServiceSupplyPoints":[{"uriValue":"http://supply.points","ServiceType":"http://supply.pointstype"}],"ServiceDefinitionURI":[{"lang":"en","uriValue":"https://www.llv.li/en/mdl/service/information"}]}}]}]}}.gmYwKrXooWgMVfF9ydBl09lJ3npE7Qu34wEvWlzeXY3T7HOOC0_NmDhyj67kYDhcPAtv40zdpwyY0EgL6ZUlJJuaCfNOzQcCrX3VDrbRzU_9yJQMkN9WV8RIB_5GpP5UIlyFJMW7NvxYKyD9TE6jzeHAbPbR2ESiFdf4iQvYo1iv5V_SoknkqfPOpRYgTXAm4PdjnlZdYqe6KXuXhwu0wpVUX3sqGqzTBJPDTkaePfUxkN5uuVwIIzv9-wK5MbUp38tMA5kN_myiTBiJcecETqG1YIPpO3DplyaUCorBIsVCrOzaai_4opaObvWI7Zgjb6OU5o7vn9m84JGskCJbUI0tvmn-M5joCDGmxhfqcCY6uFgQLHWFh71Gj4ZeEk7zB97sOJB2UbOj7kgXw2JOa-6I44CTYZWH5sww2FKLUHaKK5etSZtIXF9fIbpkP_YttNpuY3OoNw0ceBPUF-FhYsKWI0gY1TNNG65mCFTNUy5_vip-fRU7zgqrZ2c8_nOeAMMKUnX6vxqSZJ8mRONlG3hk6FujARGqAlxR1RbC9BW6eT27U98uNN1ge5bzP0Lf7bwhwWBgY2PcekVO2W3a4ynSWRDceVdEesFQgSRscNxurMm11ofHVu5K6G-kcH2hbj8O8SLNYmpzwoWiDLD5dsvRtuYEKb9HT-5w-7xHKtw" - -val LoTEClientTest by testSuite { - - data class Context( - val mockEngine: MockEngine, - val client: LoTEClient, - ) - - fun setup(): Context { - val mockEngine = MockEngine { request -> - val requestedUrl = request.url.toString().substringBefore("?") - - val responsePayload = when (requestedUrl) { - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" -> PID_PROVIDERS_JWS - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wallet-providers.json" -> WALLET_PROVIDERS_JWS - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers.json" -> WRPAC_PROVIDERS_JWS - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/mdl-providers.json" -> MDL_PROVIDERS_JWS - else -> null - } - - if (responsePayload != null) { - respond( - content = ByteReadChannel(responsePayload), - status = HttpStatusCode.OK, - headers = headersOf(HttpHeaders.ContentType, MediaTypes.Application.JSON) - ) - } else { - respond( - content = ByteReadChannel("Not Found"), - status = HttpStatusCode.NotFound - ).also { Napier.w("LoTE Mock Engine: URL NOT MATCHED $requestedUrl") } - } - } - - return Context( - mockEngine = mockEngine, - client = LoTEClient( - engine = mockEngine, - verifyJwsObject = VerifyJwsObject() - ) - ) - } - - listOf( - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/pid-providers.json" to "PID Providers Acceptance", - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wallet-providers.json" to "Wallet Providers Acceptance", - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/wrpac-providers.json" to "WRPAC Providers Acceptance", - "https://acceptance.trust.tech.ec.europa.eu/lists/eudiw/mdl-providers.json" to "mDL Providers Acceptance", - ).forEach { (url, listName) -> - - test("fetch and validate trust list: $listName") { - with(setup()) { - val result = client.fetchTrustList(url) - - result.isSuccess shouldBe true - - val lote = result.getOrThrow() - lote.trustedEntitiesList shouldNotBe null - } - } - } -} \ No newline at end of file diff --git a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt index d020e5bf7..50f70c795 100644 --- a/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt +++ b/vck/src/commonTest/kotlin/at/asitplus/wallet/lib/jws/JwsServiceTest.kt @@ -1,7 +1,6 @@ package at.asitplus.wallet.lib.jws import at.asitplus.catching -import at.asitplus.dcapi.request.DCAPIWalletRequest import at.asitplus.signum.indispensable.Digest import at.asitplus.signum.indispensable.josef.JwsCompactTyped import at.asitplus.signum.indispensable.io.Base64UrlStrict @@ -12,30 +11,26 @@ import at.asitplus.signum.indispensable.josef.JweEncryption import at.asitplus.signum.indispensable.josef.JweHeader import at.asitplus.signum.indispensable.josef.JwsCompact import at.asitplus.signum.indispensable.josef.JwsHeader -import at.asitplus.signum.indispensable.josef.JwsSigned import at.asitplus.signum.indispensable.josef.io.joseCompliantSerializer import at.asitplus.signum.indispensable.pki.leaf import at.asitplus.signum.supreme.hash.digest import at.asitplus.signum.supreme.sign.Verifier -import at.asitplus.testballoon.withFixtureGenerator -import at.asitplus.wallet.lib.agent.EphemeralKeyWithSelfSignedCert +import at.asitplus.testballoon.matrix.* import at.asitplus.wallet.lib.agent.EphemeralKeyWithoutCert import at.asitplus.wallet.lib.agent.KeyMaterial import com.benasher44.uuid.uuid4 import at.asitplus.testballoon.matrix.matrixSuite +import at.asitplus.wallet.lib.agent.EphemeralKeyWithSelfSignedCert import io.kotest.assertions.throwables.shouldThrowAny import io.kotest.matchers.nulls.shouldNotBeNull import io.kotest.matchers.shouldBe import io.matthewnelson.encoding.base64.Base64 -import io.matthewnelson.encoding.core.Decoder.Companion.decodeToByteArray import io.matthewnelson.encoding.core.Encoder.Companion.encodeToString import kotlinx.serialization.builtins.ByteArraySerializer import kotlinx.serialization.builtins.serializer import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.buildJsonObject -import kotlinx.serialization.json.jsonObject import kotlinx.serialization.json.put -import net.orandja.obor.codec.Cbor.Companion.copy import kotlin.random.Random val JwsServiceTest by matrixSuite { @@ -136,9 +131,7 @@ val JwsServiceTest by matrixSuite { .payload shouldBe it.randomPayload } - val dummyVerifier = object : VerifyJwsObjectFun { - override suspend fun invoke(jwsObject: JwsCompact) = catching { Verifier.Success } - } + val dummyVerifier = VerifyJwsObjectFun { catching { Verifier.Success } } val jadesVerifier = VerifyJwsObjectJades(verifyJwsObject = dummyVerifier) test("JAdES verification passes with valid x5t#o parameter (SHA-384)") { diff --git a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt index eb6a5cb1f..74beaae75 100644 --- a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/LoTEFilterTest.kt @@ -1,12 +1,12 @@ package at.asitplus.wallet.lib.etsi import at.asitplus.etsi.ListOfTrustedEntities -import at.asitplus.testballoon.withData -import de.infix.testBalloon.framework.core.testSuite +import at.asitplus.testballoon.matrix.matrixSuite + import io.kotest.matchers.shouldNotBe import kotlinx.serialization.json.Json -val LoTEFilterTest by testSuite { +val LoTEFilterTest by matrixSuite { val pidProvidersOriginal = """ { @@ -7033,13 +7033,12 @@ val LoTEFilterTest by testSuite { ) testSuite("filter lote by type identifier") { - withData( - nameFn = { it.first }, // Uses the key as the test name + mapOf( "pidProviders" to TestData(pidProvidersFixed, "http://uri.etsi.org/19602/SvcType/PID/Issuance"), "walletProviders" to TestData(walletProvidersFixed, "http://uri.etsi.org/19602/SvcType/WalletSolution/Issuance"), "wrpacProviders" to TestData(wrpacProvidersFixed, "http://uri.etsi.org/19602/SvcType/WRPAC/Issuance"), "mdlProviders" to TestData(mdlProvidersFixed, "http://uri.etsi.org/19602/SvcType/mDL/Issuance"), - ) { (_, data) -> + ).asData() test{ (_, data) -> val lote = Json.decodeFromString(data.json) val criteria = LoTEFilterCriteria(expectedServiceType = data.expectedServiceType) diff --git a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt index 410269bba..11207fa0e 100644 --- a/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt +++ b/vck/src/jvmTest/kotlin/at/asitplus/wallet/lib/etsi/TrustListValidatorTest.kt @@ -1,12 +1,11 @@ package at.asitplus.wallet.lib.etsi import at.asitplus.signum.indispensable.pki.X509Certificate -import de.infix.testBalloon.framework.core.testSuite +import at.asitplus.testballoon.matrix.matrixSuite import io.kotest.matchers.shouldBe -import at.asitplus.testballoon.invoke -val TrustListValidatorTest by testSuite { +val TrustListValidatorTest by matrixSuite { val trustAnchorPem = "-----BEGIN CERTIFICATE-----\n" + "MIIDRzCCAi+gAwIBAgIBATANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJVUzEf\n" + From f424f079f66bbfd2d280be17bbe39feb3c847d69 Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Wed, 17 Jun 2026 11:58:52 +0200 Subject: [PATCH 15/16] update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3dfb8787a..b6816ddf3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -53,6 +53,7 @@ Release 6.0.0 (unreleased): - Add `LoTEFilterService` for extracting trust list certificates from `LoTE` based on `ServiceTypeIdentifier` - Add signature and time validity checks of certificate against the trust list - Add JAdES B-B validation (Used when fetching LoTE) + - Add `issuer` property in `StoreEntry`, for evaluation of trust against trust list Release 5.12.0: - W3C JWT VC: From c02e4da1b0134128d8e5ae314bb99d991fcaf33d Mon Sep 17 00:00:00 2001 From: Srdjan Stjepanovic Date: Thu, 25 Jun 2026 10:46:18 +0200 Subject: [PATCH 16/16] polishing --- .../etsi/EtsiX509CertificateSerializer.kt | 24 ++++--------------- 1 file changed, 5 insertions(+), 19 deletions(-) diff --git a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt index ea51fc936..676650870 100644 --- a/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt +++ b/etsi-data-classes/src/commonMain/kotlin/at/asitplus/etsi/EtsiX509CertificateSerializer.kt @@ -37,25 +37,11 @@ class EtsiX509CertificateSerializer : KSerializer { } override fun deserialize(decoder: Decoder): X509Certificate? = try { - when (decoder) { - is JsonDecoder -> { - val jsonObject = decoder - .decodeJsonElement() - .jsonObject - - val base64 = jsonObject[ - EtsiX509CertificateSerializationSurrogate.SerialNames.VALUE - ]?.jsonPrimitive?.content ?: return null - - val bytes = Base64.Default.decode(base64) - - X509Certificate.decodeFromByteArray(bytes) - } - else -> { - decoder.decodeSerializableValue( - EtsiX509CertificateSerializationSurrogate.serializer(), - ).value - } + if (decoder is JsonDecoder) { + val element = decoder.decodeJsonElement() + decoder.json.decodeFromJsonElement(delegate, element).value + } else { + decoder.decodeSerializableValue(delegate).value } } catch (_: Exception) { null