Enterprise édition

Listes de confiance (TSL)

En un coup d’œil

La validation de signature dans l’UE part d’un fait publié : quels prestataires détiennent le statut qualifié. Ce fait réside dans les listes de confiance (TSL) — des documents XML signés que chaque État membre publie, indexés par la liste des listes de confiance de l’UE (LOTL). NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer transforme une URL de TSL ou du XML brut en un TslDocument sur lequel tu peux compter. Il récupère via un HTTPS protégé, vérifie la signature XMLDSig contre les ancres que tu épingles, analyse du XML durci et rejette les listes périmées. Un appel supplémentaire, TslTrustAnchorProvider::buildBundle(), convertit les services CA/QC actifs en un lot d’ancres de confiance versionné. Chaque contrôle échoue en mode fermé ; chaque rejet est une exception typée.

Cette page couvre l’ingestion des listes et la dérivation des ancres. La validation du chemin de certification est traitée dans Vérification de signature. Le mappage des niveaux de garantie eIDAS est traité dans Niveaux de garantie eIDAS. La liaison de confiance des conteneurs est traitée dans Liaison de confiance ASiC.

Disponibilité et licence

Cette fonctionnalité est fournie dans NextPDF Enterprise (nextpdf/enterprise) et s’active avec une enveloppe de licence de niveau Enterprise. Un déploiement sans ce droit ne charge pas les classes de la fonctionnalité. Compare les éditions et obtiens une licence.

Installation

composer require nextpdf/enterprise

L’activation nécessite ton enveloppe de licence Enterprise. Voir Installer et authentifier. Les classes de cette page résident sous NextPDF\Enterprise\Security\Tsl ; les types de politique réseau résident sous NextPDF\Enterprise\Security. La récupération en ligne nécessite en plus n’importe quel client PSR-18 et fabrique PSR-17 (par exemple guzzlehttp/guzzle).

Vue d’ensemble conceptuelle

Selon l’article 22 d’eIDAS, chaque État membre publie une liste de confiance de ses prestataires de services de confiance qualifiés, signée ou scellée pour un traitement automatisé. ETSI TS 119 612 définit le format XML. La liste n’est digne de confiance que dans la mesure où trois contrôles la rendent telle : sa signature, sa structure et sa fraîcheur. NextPDF les exécute dans cet ordre, comme un seul pipeline :

Récupérer — TslFetcher récupère le XML via HTTPS uniquement. Une protection SSRF valide l’hôte avant toute sortie. Les réponses sont plafonnées en taille, et un cache PSR-16 permet la revalidation ETag et les lectures en environnement isolé.
Vérifier — TslSignatureVerifier contrôle la signature XMLDSig enveloppée. Le certificat de signature doit se chaîner jusqu’à une ancre de confiance que tu as épinglée hors bande ; rien à l’intérieur du document n’est digne de confiance par lui-même.
Analyser — TslXmlParser extrait les informations de schéma et chaque service TSP dans un TslDocument immuable. Les documents porteurs d’un DOCTYPE sont rejetés avant la construction de toute table d’entités.
Appliquer — l’instant NextUpdate de la liste ne doit pas être dépassé. Une liste périmée est écartée, jamais consommée.

TslPolicyEnforcer compose les quatre ; un TslDocument qui en provient a franchi chaque contrôle. À partir de là, TslTrustAnchorProvider::buildBundle() filtre les services qui sont à la fois en statut granted et de type CA/QC, et émet un EnterpriseCaTrustAnchorBundle : des ancres PEM épinglées, une version tsl-<territory>-seq<N> et une empreinte d’intégrité SHA-256. C’est ce lot que consomment la validation de chemin et la liaison de confiance ASiC.

La même mécanique couvre le workflow LOTL. Vérifie la LOTL contre une ancre épinglée manuellement ; puis vérifie chaque TSL d’État membre contre les certificats de signature que la LOTL déclare pour elle.

Pourquoi cela fonctionne ainsi

La décision porteuse est un profil de vérification fixe et minimal plutôt que du XMLDSig général. Le traitement flexible des signatures XML — chaînes de transformations arbitraires, références d’ID déclarées par l’attaquant, agilité algorithmique — est là où les vérificateurs se brisent historiquement. Le vérificateur accepte donc exactement un modèle de traitement : C14N exclusif, une référence couvrant la racine et le pipeline à deux transformations [enveloped-signature, exclusive-C14N], tout le reste étant rejeté en mode fermé. La confiance ne s’amorce jamais depuis le document lui-même : les certificats KeyInfo ne se chaînent qu’aux ancres que tu as configurées. La fraîcheur réside sur le TslDocument lui-même, de sorte que chaque chemin consommateur l’applique plutôt qu’un unique collaborateur optionnel. Le résultat est un noyau réduit, testable, déterministe et honnête sur ce qu’il refuse.

Contexte de conception : Les signatures qualifiées, expliquées.

Surface d’API

`TslPolicyEnforcer`

Le point d’entrée orchestré : récupération, vérification, analyse et contrôle de fraîcheur en un seul appel.

public function __construct(
    private readonly TslFetcher $fetcher,
    private readonly TslSignatureVerifier $verifier,
    private readonly TslXmlParser $parser,
) {}

public function fetchAndVerify(string $url): TslDocument

public function verifyXml(string $xml): TslDocument

Lève ou échoue avec : TslFetchException et NextPDF\Enterprise\Security\NetworkPolicyViolation à l’étape de récupération ; TslSignatureException à la vérification de signature ; TslParseException à l’analyse, sur une valeur NextUpdate non canonique, ou sur une liste périmée. Les deux méthodes ne renvoient un TslDocument que lorsque chaque contrôle a réussi. Le contrôle de péremption compare ici NextUpdate à l’horloge système actuelle.

`TslFetcher`

Récupérateur HTTP avec mise en cache basée sur ETag et un contrôle de politique réseau.

public function __construct(
    private readonly ClientInterface $httpClient,
    private readonly RequestFactoryInterface $requestFactory,
    private readonly ?CacheInterface $cache = null,
    private readonly int $defaultTtlSeconds = 3600,
    private readonly int $maxBytes = 16_777_216,
    private readonly NetworkPolicy $networkPolicy = NetworkPolicy::ONLINE,
) {}

public function fetch(string $url): string

Lève ou échoue avec : TslFetchException sur une URL non HTTPS, un hôte rejeté (SSRF), un statut d’erreur HTTP, une réponse trop volumineuse ou un corps vide ; NetworkPolicyViolation lorsque NetworkPolicy::STRICT_OFFLINE est actif et qu’aucun corps mis en cache n’existe. Les corps mis en cache satisfont la revalidation 304 Not Modified et sont les seuls corps servis sous STRICT_OFFLINE. Les entrées de cache vivent pendant $defaultTtlSeconds.

`TslSignatureVerifier`

Vérificateur XMLDSig pour les listes de confiance signées.

public function __construct(
    private readonly array $trustAnchorsPem,
    private readonly int $clockTolerance = 0,
)

public function verify(string $xml): string

verify() renvoie le PEM du certificat de signature, dont il est prouvé qu’il se chaîne à l’un des $trustAnchorsPem. Le constructeur lève InvalidArgumentException lorsque la liste d’ancres est vide. $clockTolerance élargit symétriquement la fenêtre de validité du certificat, en secondes.

Le profil accepté est fixe. Algorithmes de signature : la liste d’autorisation ALLOWED_SIG_ALG (rsa-sha256/384/512, ecdsa-sha256/384/512). Empreintes : la liste d’autorisation ALLOWED_DIGEST_ALG (SHA-256, SHA-384, SHA-512). Canonicalisation : C14N exclusif 1.0 uniquement. SHA-1 et MD5 sont rejetés en tant que unsupported_algorithm.

Lève ou échoue avec : TslSignatureException, portant un reason lisible par machine :

Code de motif	Signification
`missing_signature`	Le document n’a aucun élément `ds:Signature`.
`untrusted_signer`	Le certificat `KeyInfo` ne se chaîne à aucune ancre configurée.
`invalid_signature`	Défaut structurel, ou échec du contrôle RSA/ECDSA.
`digest_mismatch`	L’empreinte de référence ne correspond pas au document canonicalisé.
`unsupported_algorithm`	Algorithme de signature ou d’empreinte hors de la liste d’autorisation.
`unsupported_transform`	Pipeline de canonicalisation ou de transformation hors du profil fixe.
`expired_anchor`	Un certificat de la chaîne est hors de sa fenêtre de validité, ou sa validité est inanalysable.

`TslXmlParser`

Analyseur structurel agnostique de signature. Les appelants DOIVENT vérifier avant de faire confiance à sa sortie ; TslPolicyEnforcer applique cet ordre pour toi.

public function parse(string $xml): TslDocument

Lève ou échoue avec : TslParseException lorsque le XML déclare un DOCTYPE (durcissement XXE et expansion d’entités), ne peut pas être analysé, ne possède pas la racine TrustServiceStatusList, ou porte un TSLSequenceNumber invalide. La classe expose les constantes de namespace NS_TSL, NS_DSIG et NS_TSL_X.

`TslDocument` et `TspService`

TslDocument est un objet valeur immuable : schemeTerritory, schemeOperatorName, tslType, sequenceNumber, issueDateTime, nextUpdate, tspServices et rawXmlSha256 (empreinte de preuve sur les octets bruts).

public function isStale(DateTimeImmutable $now): bool

public function assertFresh(DateTimeImmutable $now): void

public function servicesOfType(string $serviceTypeIdentifier): array

public function activeServices(): array

Lève ou échoue avec : isStale() et assertFresh() lèvent TslParseException lorsque nextUpdate n’est pas un dateTime UTC canonique avec un Z explicite ou un décalage numérique ; une liste périmée fait lever assertFresh(). activeServices() ne renvoie que les services en statut granted. servicesOfType() filtre par URI de type de service ETSI.

Chaque entrée TspService expose tspName, serviceName, serviceTypeIdentifier, serviceStatus, statusStartingTime, serviceCertificatePem, qualifiers et additionalServiceInformation, plus :

public function isGranted(): bool

public function isQualifiedCa(): bool

Constantes utiles : TspService::STATUS_GRANTED, TspService::STATUS_WITHDRAWN, TspService::TYPE_CA_QC, TspService::TYPE_OCSP_QC, TspService::TYPE_TSA_QTST. Les URI de qualificateur (par exemple TspServiceQualifier::FOR_ESIG, FOR_ESEAL, QSCD_STATEMENT, NO_QSCD) apparaissent sur TspServiceQualifier pour la couche de mappage eIDAS.

`TslTrustAnchorProvider` et le lot d’ancres

public function buildBundle(TslDocument $tsl, DateTimeImmutable $now): EnterpriseCaTrustAnchorBundle

Lève ou échoue avec : TslParseException lorsque la TSL est périmée à $now, lorsque nextUpdate n’est pas une valeur UTC canonique, ou lorsque la liste ne contient aucun service CA/QC actif.

Note BC — la règle de fraîcheur buildBundle($now). buildBundle() exige l’instant de validation et appelle TslDocument::assertFresh($now) avant d’extraire la moindre ancre. Des révisions antérieures pouvaient dériver des ancres d’un TslDocument produit par l’analyseur sans aucun contrôle de fraîcheur. Les appelants qui fournissaient des listes mises en cache ou archivées doivent désormais transmettre l’instant auquel leur validation s’exécute ; une liste périmée à cet instant lève une exception au lieu d’amorcer silencieusement des ancres de confiance.

L’EnterpriseCaTrustAnchorBundle renvoyé est un objet valeur en lecture seule : anchorsPem (les ancres PEM), bundleVersion (tsl-<territory>-seq<N>) et bundleSha256 (empreinte d’intégrité sur la concaténation PEM canonicalisée). Obtiens-le depuis buildBundle() ; ne le construis pas à la main — le constructeur lève InvalidArgumentException sur une non-correspondance d’empreinte ou un PEM malformé.

public function containsFingerprint(string $anchorDerSha256Hex): bool

public static function computeBundleSha256(array $anchorsPem): string

Exemple de code — Démarrage rapide

Authentifie et consomme une liste de confiance mise en miroir localement. Aucune dépendance HTTP n’est nécessaire pour ce chemin : vérifie, analyse, puis contrôle la fraîcheur à ton instant de validation.

<?php

declare(strict_types=1);

require __DIR__ . '/vendor/autoload.php';

use NextPDF\Enterprise\Security\Tsl\TslParseException;
use NextPDF\Enterprise\Security\Tsl\TslSignatureException;
use NextPDF\Enterprise\Security\Tsl\TslSignatureVerifier;
use NextPDF\Enterprise\Security\Tsl\TslXmlParser;

// The list-signing certificate, pinned OUT-OF-BAND. Never take it from the list itself.
$pinnedAnchorPem = (string) file_get_contents(__DIR__ . '/tsl-signer-anchor.pem');

// A trusted-list XML document you mirrored locally.
$tslXml = (string) file_get_contents(__DIR__ . '/member-state-tsl.xml');

try {
    // 1. Authenticate: XMLDSig must verify AND the signer must chain to the pinned anchor.
    (new TslSignatureVerifier(trustAnchorsPem: [$pinnedAnchorPem]))->verify($tslXml);

    // 2. Parse the now-authenticated bytes.
    $tsl = (new TslXmlParser())->parse($tslXml);

    // 3. Freshness: refuse a list whose NextUpdate has passed.
    $tsl->assertFresh(new DateTimeImmutable('now', new DateTimeZone('UTC')));
} catch (TslSignatureException $e) {
    fwrite(STDERR, "TSL rejected ({$e->reason}): {$e->getMessage()}" . PHP_EOL);
    exit(1);
} catch (TslParseException $e) {
    fwrite(STDERR, 'TSL unusable: ' . $e->getMessage() . PHP_EOL);
    exit(1);
}

echo "Territory: {$tsl->schemeTerritory}\n";
echo "Sequence: {$tsl->sequenceNumber}\n";
echo 'Active services: ' . count($tsl->activeServices()) . "\n";

Sortie attendue (les valeurs varient selon la liste) :

Territory: DE
Sequence: 127
Active services: 143

Exemple de code — Production

Câble le pipeline en ligne complet : récupération protégée avec mise en cache, vérification de signature, analyse, fraîcheur, puis dérivation du lot d’ancres. Chaque classe d’échec est capturée et signalée distinctement.

<?php

declare(strict_types=1);

require __DIR__ . '/vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Psr7\HttpFactory;
use NextPDF\Enterprise\Security\NetworkPolicy;
use NextPDF\Enterprise\Security\NetworkPolicyViolation;
use NextPDF\Enterprise\Security\Tsl\TslFetchException;
use NextPDF\Enterprise\Security\Tsl\TslFetcher;
use NextPDF\Enterprise\Security\Tsl\TslParseException;
use NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer;
use NextPDF\Enterprise\Security\Tsl\TslSignatureException;
use NextPDF\Enterprise\Security\Tsl\TslSignatureVerifier;
use NextPDF\Enterprise\Security\Tsl\TslTrustAnchorProvider;
use NextPDF\Enterprise\Security\Tsl\TslXmlParser;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
use Symfony\Component\Cache\Psr16Cache;

// Any PSR-18 client, PSR-17 factory, and PSR-16 cache work; these are examples.
$enforcer = new TslPolicyEnforcer(
    fetcher: new TslFetcher(
        httpClient: new Client(),
        requestFactory: new HttpFactory(),
        cache: new Psr16Cache(new FilesystemAdapter('tsl')),
        defaultTtlSeconds: 3600,
        maxBytes: 16_777_216,
        networkPolicy: NetworkPolicy::ONLINE,
    ),
    verifier: new TslSignatureVerifier(
        trustAnchorsPem: [(string) file_get_contents(__DIR__ . '/tsl-signer-anchor.pem')],
        clockTolerance: 300,
    ),
    parser: new TslXmlParser(),
);

// Use the official publication URL for your scheme territory (HTTPS required).
$tslUrl = 'https://trusted-lists.example.eu/member-state-tsl.xml';
$now = new DateTimeImmutable('now', new DateTimeZone('UTC'));

try {
    $tsl = $enforcer->fetchAndVerify($tslUrl);
    $bundle = (new TslTrustAnchorProvider())->buildBundle($tsl, $now);
} catch (NetworkPolicyViolation $e) {
    // Air-gapped posture: egress forbidden and no cached body available.
    fwrite(STDERR, 'Network policy: ' . $e->getMessage() . PHP_EOL);
    exit(75);
} catch (TslFetchException $e) {
    // Transport layer: SSRF-rejected URL, HTTP error, oversized or empty body.
    fwrite(STDERR, 'Fetch failed: ' . $e->getMessage() . PHP_EOL);
    exit(1);
} catch (TslSignatureException $e) {
    // Authentication layer: treat as a potential attack, not a retry case.
    fwrite(STDERR, "Signature rejected ({$e->reason}): {$e->getMessage()}" . PHP_EOL);
    exit(1);
} catch (TslParseException $e) {
    // Structure or freshness: stale list, malformed NextUpdate, no active CA/QC services.
    fwrite(STDERR, 'List unusable: ' . $e->getMessage() . PHP_EOL);
    exit(1);
}

printf(
    "Anchor bundle %s: %d anchors (sha256 %s...)\n",
    $bundle->bundleVersion,
    count($bundle->anchorsPem),
    substr($bundle->bundleSha256, 0, 12),
);

Sortie attendue (les valeurs varient selon la liste) :

Anchor bundle tsl-de-seq127: 96 anchors (sha256 4b0e2a9f31c8...)

Enregistre bundleVersion et bundleSha256 à chaque validation que tu effectues contre le lot. Ils nomment l’ensemble exact d’ancres derrière chaque verdict.

Cas limites et pièges

Le contrôle de fraîcheur de l’enforcer utilise l’horloge actuelle. fetchAndVerify() et verifyXml() rejettent une liste dont le NextUpdate est déjà dépassé. Pour une validation historique contre une liste archivée, pilote directement TslSignatureVerifier et TslXmlParser, puis appelle assertFresh() avec l’instant passé que tes preuves justifient.
buildBundle() réaffirme la fraîcheur à ton $now. Une liste qui a franchi l’enforcer peut tout de même être rejetée ici si ton instant de validation est postérieur. Voir la note BC ci-dessus.
N’amorce jamais trustAnchorsPem depuis la liste que tu vérifies. L’ancre doit provenir d’une source épinglée hors bande (pour la LOTL) ou d’une liste parente déjà vérifiée (pour les TSL d’État membre). Toute autre solution rend la vérification circulaire.
Un DOCTYPE où que ce soit est fatal. Les TSL conformes ne portent jamais de DTD, donc l’analyseur rejette tout DOCTYPE avant que libxml ne construise une table d’entités. C’est un durcissement intentionnel, non une limitation de l’analyseur.
Les champs structurels manquants se dégradent en toute sécurité. Un service sans statut lisible est traité comme retiré, de sorte qu’il ne peut jamais devenir une ancre. Un territoire de schéma manquant s’analyse comme unknown. Des valeurs par défaut fail-closed tiennent les entrées malformées hors du matériel de confiance.
Les intermédiaires doivent être de vraies AC. Lors de la construction de la chaîne, un émetteur candidat sans basicConstraints cA=TRUE (ou affirmant keyUsage sans keyCertSign) est ignoré. Un certificat d’entité finale glissé dans KeyInfo ne peut pas servir d’intermédiaire de chemin. Les chaînes sont plafonnées à une profondeur de 8.
NextUpdate doit être un UTC canonique. Une valeur sans Z explicite ni décalage numérique lève TslParseException. Elle n’est jamais réinterprétée dans le fuseau horaire local du serveur.
Les grandes listes et le plafond d’octets. Les réponses sont lues jusqu’à $maxBytes (16 Mio par défaut). Relève le plafond dans le constructeur si la liste de ton schéma est plus grande ; la troncature se manifeste comme un échec de signature, jamais comme une acceptation silencieuse.
clockTolerance ne fait qu’élargir. Il ajoute une marge symétrique aux contrôles de validité des certificats. Il ne relâche pas le contrôle de fraîcheur au niveau de la liste.

Notes de sécurité

Vérifie avant d’analyser, toujours. TslXmlParser est agnostique de signature par conception. TslPolicyEnforcer ordonne la vérification en premier ; si tu composes les pièces toi-même, conserve cet ordre.
Défense SSRF en profondeur. fetch() exige https:// et valide l’hôte contre les plages privées, de bouclage, link-local, CGN et de métadonnées cloud, avec résolution DNS A et AAAA pour atténuer le rebinding. Une URL rejetée lève une exception avant toute sortie.
Durcissement XXE et expansion d’entités. Les documents porteurs d’un DOCTYPE sont rejetés avant l’existence de la table d’entités et de nouveau après le chargement. Le chargement d’entités réseau est désactivé ; les entités externes ne sont jamais substituées.
Profil XMLDSig strict. C14N exclusif uniquement ; exactement la paire de transformations [enveloped-signature, exclusive-C14N] ; la référence vérifiée doit couvrir la racine du document ; la transformation enveloppée ne retire que la signature vérifiée, en préservant les signatures sœurs. Les algorithmes dépréciés (SHA-1, MD5) sont rejetés.
Discipline de chaîne. Chaque maillon de la chaîne — signataire, intermédiaires et le cas d’ancre directe — est contrôlé pour sa validité temporelle, en mode fermé sur des bornes de validité inanalysables. Les boucles sont détectées ; la profondeur est plafonnée.
Posture d’isolation réseau. Sous NetworkPolicy::STRICT_OFFLINE, le chemin de récupération n’effectue aucune sortie sortante ; seul un corps précédemment mis en cache peut être servi, et tout le reste lève NetworkPolicyViolation en échec rapide.
Les empreintes de lot détectent la corruption, pas la falsification. bundleSha256 est validée à la construction et détecte les dérives de transcription. Lorsque l’empreinte est dérivée des mêmes ancres qu’elle protège, elle ne constitue pas une preuve de falsification indépendante. Épingle les empreintes hors bande lors du transport de lots entre systèmes.

Conformité

Le pipeline consomme les listes de confiance telles qu’ETSI TS 119 612 les définit : il authentifie la signature de l’opérateur de schéma (§5.7), analyse les informations de schéma et les structures de liste de prestataires (§5.3, §5.4, §5.5), applique les règles de dateTime UTC (§5.1.3), et écarte les listes dont le NextUpdate est dépassé (§5.3.15). Cela prend en charge le modèle de l’article 22 d’eIDAS de listes de confiance signées et exploitables par machine. La construction de chaîne applique les contrôles de basic-constraints et de key-usage de RFC 5280 aux émetteurs candidats.

La prise en charge n’est pas la conformité, et la conformité n’est pas la certification. NextPDF implémente les contrôles que cette page décrit ; il n’a été certifié contre ETSI TS 119 612, eIDAS ni aucune autre norme par aucun organisme, et NextPDF ne détient aucune certification et n’en accorde aucune. Consommer une liste de confiance via cette API ne rend pas à elle seule une signature « qualifiée » ou juridiquement valable. Savoir si ton processus de validation complet satisfait une exigence légale ou d’appel d’offres est une détermination qui revient à tes évaluateurs.

Comportement en mode FIPS

La vérification de signature TSL exécute les contrôles RSA et ECDSA en interne via la bibliothèque cryptographique fournie. Elle n’est pas routée par le garde d’exécution du mode FIPS Enterprise, et activer le mode FIPS ne change pas son comportement. Ce n’est pas un service cryptographique validé FIPS, et aucune certification FIPS 140 n’est revendiquée. Les déploiements soumis à des obligations FIPS doivent cadrer cette API en conséquence et consulter Politique cryptographique FIPS 140-2/3.

Contrat de comportement

fetch() n’effectue de sortie que pour les URL HTTPS qui passent la validation SSRF, lit au plus $maxBytes, et respecte la NetworkPolicy configurée ; sous STRICT_OFFLINE, seul un corps mis en cache est jamais renvoyé.
Aucune sortie d’analyseur ne devient du matériel de confiance avant que verify() réussisse ; TslPolicyEnforcer garantit cet ordre.
verify() ne renvoie le PEM du signataire que lorsque l’empreinte et la signature sont validées sous le profil fixe et que le signataire se chaîne, dans une profondeur de 8 et avec chaque maillon temporellement valide, à une ancre configurée.
L’enforcer rejette toute liste dont le NextUpdate est dépassé à l’horloge actuelle ; buildBundle() réaffirme la fraîcheur à l’instant fourni par l’appelant avant de dériver les ancres.
Les ancres dérivent exclusivement de services en statut granted avec le type de service CA/QC ; un ensemble actif vide lève une exception plutôt que de produire un lot vide.
Chaque échec est une exception typée (TslFetchException, NetworkPolicyViolation, TslSignatureException avec un code de motif, TslParseException) ; aucune méthode ne renvoie un document partiel ou non vérifié.

Repli Core

NextPDF Core valide les signatures PDF contre des ancres de confiance que tu épingles explicitement via son contrat CaTrustAnchorBundle — voir Sécurité Core. Core n’a aucune capacité de liste de confiance : pas de récupération de TSL, pas d’authentification de liste XMLDSig, pas d’analyse ETSI TS 119 612, et pas de dérivation d’ancres à partir d’entrées de service qualifié. Avec Core seul, tu maintiens ton ensemble d’ancres à la main ; le dériver de listes de confiance UE authentifiées nécessite NextPDF Enterprise.

Limite de publication

Cette page ne documente que le comportement observable de l’extérieur et la surface d’API publique prise en charge. Les chemins de namespace internes, les classes utilitaires, les tables de mécanismes, les noms de fichiers de runbook et les préfixes de tickets sont hors périmètre.

Voir aussi

Liaison de confiance ASiC — lie les signataires de conteneurs aux lots d’ancres que cette page dérive.
Niveaux de garantie eIDAS — mappe les preuves TspService aux niveaux de garantie.
Vérification de signature — le côté vérification qui consomme les ancres de confiance pour la validation de chemin.
Sécurité — référence approfondie — la référence au niveau contrat du module de sécurité Enterprise.
Les signatures qualifiées, expliquées — pourquoi les listes de confiance ancrent le modèle de confiance de l’UE.
Validation à long terme — pourquoi le temps de validation et les preuves conservées comptent.