Enterprise editie

Trusted lists (TSL)

In één oogopslag

EU-handtekeningvalidatie begint bij een gepubliceerd feit: welke aanbieders gekwalificeerde status hebben. Dat feit staat in trusted lists (TSL’s) — ondertekende XML-documenten die elke lidstaat publiceert, geïndexeerd door de EU-lijst van trusted lists (LOTL). NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer zet een TSL-URL of ruwe XML om in een TslDocument waarop je kunt vertrouwen. Het haalt op via beveiligde HTTPS, verifieert de XMLDSig-handtekening tegen anchors die je vastpint, parset geharde XML en wijst verouderde lijsten af. Eén verdere aanroep, TslTrustAnchorProvider::buildBundle(), zet actieve CA/QC-diensten om in een geversioneerde trust-anchor-bundel. Elke controle faalt gesloten; elke afwijzing is een getypeerde exception.

Deze pagina gaat over het inlezen van lijsten en het afleiden van anchors. Certificaatpadvalidatie staat in Handtekeningverificatie. Het in kaart brengen van eIDAS-betrouwbaarheidsniveaus staat in eIDAS-betrouwbaarheidsniveaus. Het binden van containervertrouwen staat in ASiC trust binding.

Beschikbaarheid en licentie

Deze functionaliteit wordt geleverd in NextPDF Enterprise (nextpdf/enterprise) en activeert met een licentie-envelop op Enterprise-niveau. Een deployment zonder dat recht laadt de klassen van de functionaliteit niet. Vergelijk edities en verkrijg een licentie.

Installeren

composer require nextpdf/enterprise

Activatie vereist je Enterprise-licentie-envelop. Zie Installeren en authenticeren. De klassen op deze pagina staan onder NextPDF\Enterprise\Security\Tsl; de netwerkbeleidstypes staan onder NextPDF\Enterprise\Security. Online ophalen vereist daarnaast een willekeurige PSR-18-client en PSR-17-factory (bijvoorbeeld guzzlehttp/guzzle).

Conceptueel overzicht

Onder eIDAS Article 22 publiceert elke lidstaat een trusted list van zijn gekwalificeerde vertrouwensdienstverleners, ondertekend of verzegeld voor geautomatiseerde verwerking. ETSI TS 119 612 definieert het XML-formaat. De lijst is slechts zo betrouwbaar als drie controles die maken: de handtekening, de structuur en de versheid ervan. NextPDF voert ze in die volgorde uit, als één pipeline:

Ophalen — TslFetcher haalt de XML uitsluitend over HTTPS op. Een SSRF-guard valideert de host vóór enige uitgaande verbinding. Reacties hebben een groottelimiet, en een PSR-16 cache maakt ETag-hervalidatie en air-gapped reads mogelijk.
Verifiëren — TslSignatureVerifier controleert de enveloped XMLDSig-handtekening. Het ondertekeningscertificaat moet ketenen naar een trust anchor die je out-of-band hebt vastgepind; niets binnen het document wordt op zichzelf vertrouwd.
Parsen — TslXmlParser haalt scheme-informatie en elke TSP-dienst op in een onveranderlijk TslDocument. Documenten met een DOCTYPE worden afgewezen voordat er een entiteitstabel wordt opgebouwd.
Handhaven — het NextUpdate-moment van de lijst mag niet verstreken zijn. Een verouderde lijst wordt weggegooid, nooit geconsumeerd.

TslPolicyEnforcer combineert alle vier; een TslDocument daarvan heeft elke controle doorstaan. Van daaruit filtert TslTrustAnchorProvider::buildBundle() diensten die zowel in granted-status zijn als van het CA/QC-type, en produceert een EnterpriseCaTrustAnchorBundle: vastgepinde PEM-anchors, een tsl-<territory>-seq<N>-versie en een SHA-256 integriteitsdigest. Die bundel is wat padvalidatie en ASiC trust binding consumeren.

Dezelfde machinerie dekt de LOTL-workflow. Verifieer de LOTL tegen een handmatig vastgepinde anchor; verifieer vervolgens elke lidstaat-TSL tegen de ondertekeningscertificaten die de LOTL daarvoor declareert.

Waarom het zo werkt

De dragende beslissing is een vast, minimaal verificatieprofiel in plaats van algemene XMLDSig. Flexibele verwerking van XML-handtekeningen — willekeurige transformatieketens, door de aanvaller gedeclareerde ID-referenties, algoritme-flexibiliteit — is waar verifiers historisch gezien falen. Daarom accepteert de verifier precies één verwerkingsmodel: exclusive C14N, een referentie die de root dekt, en de pipeline met twee transformaties [enveloped-signature, exclusive-C14N], waarbij al het andere fail-closed wordt afgewezen. Vertrouwen wordt nooit vanuit het document zelf opgestart: KeyInfo-certificaten ketenen alleen ooit naar anchors die je hebt geconfigureerd. Versheid zit op TslDocument zelf, zodat elk consumentpad het handhaaft in plaats van één optionele medewerker. Het resultaat is een kleine kernel die testbaar, deterministisch en eerlijk is over wat hij weigert.

Ontwerpachtergrond: Gekwalificeerde handtekeningen, uitgelegd.

API-oppervlak

`TslPolicyEnforcer`

Het georkestreerde toegangspunt: ophalen, verifiëren, parsen en versheidscontrole in één aanroep.

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

Gooit of faalt met: TslFetchException en NextPDF\Enterprise\Security\NetworkPolicyViolation uit de ophaalfase; TslSignatureException uit handtekeningverificatie; TslParseException uit het parsen, uit een niet-canonieke NextUpdate-waarde, of uit een verouderde lijst. Beide methodes retourneren alleen een TslDocument wanneer elke controle is doorstaan. De verouderingscontrole vergelijkt hier NextUpdate met de huidige systeemklok.

`TslFetcher`

HTTP-fetcher met ETag-gebaseerde caching en een netwerkbeleidscontrole.

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

Gooit of faalt met: TslFetchException bij een niet-HTTPS-URL, een afgewezen (SSRF) host, een HTTP-foutstatus, een te grote reactie of een lege body; NetworkPolicyViolation wanneer NetworkPolicy::STRICT_OFFLINE actief is en er geen gecachete body bestaat. Gecachete bodies voldoen aan 304 Not Modified-hervalidatie en zijn de enige bodies die onder STRICT_OFFLINE worden geleverd. Cache-entries leven $defaultTtlSeconds lang.

`TslSignatureVerifier`

XMLDSig-verifier voor ondertekende trusted lists.

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

public function verify(string $xml): string

verify() retourneert de PEM van het ondertekeningscertificaat, waarvan bewezen is dat het ketent naar een van $trustAnchorsPem. De constructor gooit InvalidArgumentException wanneer de anchorlijst leeg is. $clockTolerance verbreedt het geldigheidsvenster van het certificaat symmetrisch, in seconden.

Het geaccepteerde profiel ligt vast. Handtekeningalgoritmen: de ALLOWED_SIG_ALG-allowlist (rsa-sha256/384/512, ecdsa-sha256/384/512). Digests: de ALLOWED_DIGEST_ALG-allowlist (SHA-256, SHA-384, SHA-512). Canonicalisatie: uitsluitend exclusive C14N 1.0. SHA-1 en MD5 worden afgewezen als unsupported_algorithm.

Gooit of faalt met: TslSignatureException, met een machineleesbare reason:

Reason code	Betekenis
`missing_signature`	Het document heeft geen `ds:Signature`-element.
`untrusted_signer`	Het `KeyInfo`-certificaat ketent niet naar een geconfigureerde anchor.
`invalid_signature`	Structureel defect, of de RSA/ECDSA-controle is mislukt.
`digest_mismatch`	De referentiedigest komt niet overeen met het gecanonicaliseerde document.
`unsupported_algorithm`	Handtekening- of digestalgoritme buiten de allowlist.
`unsupported_transform`	Canonicalisatie- of transformatiepipeline buiten het vaste profiel.
`expired_anchor`	Een ketencertificaat valt buiten zijn geldigheidsvenster, of zijn geldigheid is niet te parsen.

`TslXmlParser`

Handtekening-agnostische structurele parser. Aanroepers MOETEN verifiëren voordat ze de output vertrouwen; TslPolicyEnforcer handhaaft die volgorde voor je.

public function parse(string $xml): TslDocument

Gooit of faalt met: TslParseException wanneer de XML een DOCTYPE declareert (XXE- en entiteitsexpansieharding), niet kan worden geparset, de TrustServiceStatusList-root mist, of een ongeldig TSLSequenceNumber draagt. De klasse stelt de namespace-constanten NS_TSL, NS_DSIG en NS_TSL_X beschikbaar.

`TslDocument` en `TspService`

TslDocument is een onveranderlijk value object: schemeTerritory, schemeOperatorName, tslType, sequenceNumber, issueDateTime, nextUpdate, tspServices en rawXmlSha256 (bewijshash over de ruwe bytes).

public function isStale(DateTimeImmutable $now): bool

public function assertFresh(DateTimeImmutable $now): void

public function servicesOfType(string $serviceTypeIdentifier): array

public function activeServices(): array

Gooit of faalt met: isStale() en assertFresh() gooien TslParseException wanneer nextUpdate geen canoniek UTC dateTime is met een expliciete Z of numerieke offset; een verouderde lijst laat assertFresh() gooien. activeServices() retourneert alleen diensten in granted-status. servicesOfType() filtert op ETSI service-type-URI.

Elke TspService-entry stelt tspName, serviceName, serviceTypeIdentifier, serviceStatus, statusStartingTime, serviceCertificatePem, qualifiers en additionalServiceInformation beschikbaar, plus:

public function isGranted(): bool

public function isQualifiedCa(): bool

Nuttige constanten: TspService::STATUS_GRANTED, TspService::STATUS_WITHDRAWN, TspService::TYPE_CA_QC, TspService::TYPE_OCSP_QC, TspService::TYPE_TSA_QTST. Qualifier-URI’s (bijvoorbeeld TspServiceQualifier::FOR_ESIG, FOR_ESEAL, QSCD_STATEMENT, NO_QSCD) verschijnen op TspServiceQualifier voor de eIDAS-mappinglaag.

`TslTrustAnchorProvider` en de anchorbundel

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

Gooit of faalt met: TslParseException wanneer de TSL verouderd is op $now, wanneer nextUpdate geen canonieke UTC-waarde is, of wanneer de lijst geen actieve CA/QC-diensten bevat.

BC-notitie — de versheidsregel van buildBundle($now). buildBundle() vereist het validatiemoment en roept TslDocument::assertFresh($now) aan voordat het ook maar één anchor extraheert. Eerdere revisies konden anchors afleiden uit een door de parser geproduceerd TslDocument zonder enige versheidscontrole. Aanroepers die gecachete of gearchiveerde lijsten voedden, moeten nu het moment doorgeven waarop hun validatie draait; een lijst die op dat moment verouderd is, gooit in plaats van stilzwijgend trust anchors te zaaien.

De geretourneerde EnterpriseCaTrustAnchorBundle is een alleen-lezen value object: anchorsPem (de PEM-anchors), bundleVersion (tsl-<territory>-seq<N>) en bundleSha256 (integriteitsdigest over de gecanonicaliseerde PEM-concatenatie). Verkrijg het via buildBundle(); construeer het niet met de hand — de constructor gooit InvalidArgumentException bij een digest-mismatch of misvormde PEM.

public function containsFingerprint(string $anchorDerSha256Hex): bool

public static function computeBundleSha256(array $anchorsPem): string

Codevoorbeeld — Snelstart

Authenticeer en consumeer een lokaal gespiegelde trusted list. Voor dit pad is geen HTTP-afhankelijkheid nodig: verifieer, parse en controleer vervolgens de versheid op je validatiemoment.

<?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";

Verwachte uitvoer (waarden verschillen per lijst):

Territory: DE
Sequence: 127
Active services: 143

Codevoorbeeld — Productie

Bedraad de volledige online pipeline: beveiligd ophalen met caching, handtekeningverificatie, parsen, versheid en vervolgens het afleiden van de anchorbundel. Elke faalklasse wordt afzonderlijk opgevangen en gerapporteerd.

<?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),
);

Verwachte uitvoer (waarden verschillen per lijst):

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

Leg bundleVersion en bundleSha256 vast bij elke validatie die je tegen de bundel uitvoert. Ze benoemen de exacte anchorset achter elk oordeel.

Randgevallen en valkuilen

De versheidscontrole van de enforcer gebruikt de huidige klok. fetchAndVerify() en verifyXml() wijzen een lijst af waarvan NextUpdate al is verstreken. Voor historische validatie tegen een gearchiveerde lijst stuur je TslSignatureVerifier en TslXmlParser rechtstreeks aan en roep je vervolgens assertFresh() aan met het moment in het verleden dat je bewijs ondersteunt.
buildBundle() bevestigt de versheid opnieuw op jouw $now. Een lijst die de enforcer is gepasseerd, kan hier alsnog worden afgewezen als je validatiemoment later ligt. Zie de BC-notitie hierboven.
Zaai trustAnchorsPem nooit vanuit de lijst die je verifieert. De anchor moet komen uit een out-of-band vastgepinde bron (voor de LOTL) of uit een reeds geverifieerde bovenliggende lijst (voor lidstaat-TSL’s). Al het andere maakt verificatie circulair.
Een DOCTYPE waar dan ook is fataal. Conforme TSL’s dragen nooit een DTD, dus de parser wijst elke DOCTYPE af voordat libxml een entiteitstabel opbouwt. Dit is opzettelijke harding, geen beperking van de parser.
Ontbrekende structurele velden degraderen veilig. Een dienst zonder een leesbare status wordt als ingetrokken behandeld, zodat hij nooit een anchor kan worden. Een ontbrekend scheme-territory parset als unknown. Fail-closed-standaardwaarden houden misvormde entries buiten trustmateriaal.
Intermediates moeten echte CA’s zijn. Tijdens het opbouwen van de keten wordt een kandidaat-uitgever zonder basicConstraints cA=TRUE (of die keyUsage zonder keyCertSign stelt) overgeslagen. Een end-entity-certificaat dat in KeyInfo is binnengesmokkeld, kan niet dienen als pad-intermediate. Ketens worden begrensd op diepte 8.
NextUpdate moet canoniek UTC zijn. Een waarde zonder een expliciete Z of numerieke offset gooit TslParseException. Hij wordt nooit heringterpreteerd in de lokale tijdzone van de server.
Grote lijsten en de bytelimiet. Reacties worden gelezen tot $maxBytes (standaard 16 MiB). Verhoog de limiet in de constructor als de lijst van je scheme groter is; afkapping komt naar boven als een handtekeningfout, nooit als stilzwijgende acceptatie.
clockTolerance verbreedt alleen. Het voegt symmetrische speling toe aan certificaatgeldigheidscontroles. Het versoepelt niet de versheidscontrole op lijstniveau.

Beveiligingsnotities

Verifieer voor het parsen, altijd. TslXmlParser is per ontwerp handtekening-agnostisch. TslPolicyEnforcer plaatst verificatie eerst; als je de onderdelen zelf samenstelt, houd die volgorde aan.
SSRF-verdediging in de diepte. fetch() vereist https:// en valideert de host tegen private, loopback, link-local, CGN- en cloud-metadata-ranges, met A- en AAAA-DNS-resolutie om rebinding te beperken. Een afgewezen URL gooit vóór enige uitgaande verbinding.
XXE- en entiteitsexpansieharding. Documenten met een DOCTYPE worden afgewezen voordat de entiteitstabel bestaat en nogmaals na het laden. Netwerkentiteit-laden is uitgeschakeld; externe entiteiten worden nooit vervangen.
Strikt XMLDSig-profiel. Uitsluitend exclusive C14N; precies het transformatiepaar [enveloped-signature, exclusive-C14N]; de geverifieerde referentie moet de documentroot dekken; de enveloped-transformatie verwijdert alleen de geverifieerde handtekening en behoudt naburige handtekeningen. Verouderde algoritmen (SHA-1, MD5) worden afgewezen.
Ketendiscipline. Elke ketenschakel — ondertekenaar, intermediates en het directe-anchor-geval — wordt gecontroleerd op temporele geldigheid, fail-closed bij niet-parsebare geldigheidsgrenzen. Lussen worden gedetecteerd; de diepte is begrensd.
Air-gap-houding. Onder NetworkPolicy::STRICT_OFFLINE voert het ophaalpad in het geheel geen uitgaande verbinding uit; alleen een eerder gecachete body mag worden geleverd, en al het andere gooit NetworkPolicyViolation fail-fast.
Bundeldigests detecteren corruptie, geen manipulatie. bundleSha256 wordt bij constructie gevalideerd en detecteert transcriptiedrift. Wanneer de digest is afgeleid van dezelfde anchors die hij beschermt, is hij geen onafhankelijk manipulatiebewijs. Pin digests out-of-band vast bij het transporteren van bundels tussen systemen.

Conformiteit

De pipeline consumeert trusted lists zoals ETSI TS 119 612 ze definieert: het authenticeert de handtekening van de scheme-operator (§5.7), parset de scheme-informatie en de structuren van de aanbiederslijst (§5.3, §5.4, §5.5), handhaaft de UTC dateTime-regels (§5.1.3), en verwerpt lijsten waarvan NextUpdate is verstreken (§5.3.15). Dit ondersteunt het eIDAS Article 22-model van ondertekende, machineverwerkbare trusted lists. Het opbouwen van de keten past RFC 5280 basic-constraints- en key-usage-controles toe op kandidaat-uitgevers.

Ondersteuning is geen conformiteit, en conformiteit is geen certificering. NextPDF implementeert de controles die deze pagina beschrijft; het is niet gecertificeerd tegen ETSI TS 119 612, eIDAS of enige andere standaard door welke instantie dan ook, en NextPDF houdt geen certificering en verleent er geen. Een trusted list door deze API consumeren maakt een handtekening op zichzelf niet “gekwalificeerd” of juridisch geldig. Of je volledige validatieproces aan een juridische of aanbestedingseis voldoet, is een beoordeling voor je assessoren.

Gedrag in FIPS-modus

TSL-handtekeningverificatie voert RSA- en ECDSA-controles in-process uit via de meegeleverde cryptobibliotheek. Het wordt niet gerouteerd via de Enterprise FIPS-modus-runtimeguard, en het inschakelen van de FIPS-modus verandert het gedrag niet. Het is geen FIPS-gevalideerde cryptografische dienst, en er wordt geen FIPS 140-certificering geclaimd. Deployments met FIPS-verplichtingen moeten deze API dienovereenkomstig afbakenen en FIPS 140-2/3 cryptografiebeleid raadplegen.

Gedragscontract

fetch() voert alleen uitgaande verbindingen uit voor HTTPS-URL’s die de SSRF-validatie doorstaan, leest maximaal $maxBytes, en respecteert het geconfigureerde NetworkPolicy; onder STRICT_OFFLINE wordt ooit alleen een gecachete body geretourneerd.
Geen enkele parseruitvoer wordt trustmateriaal voordat verify() slaagt; TslPolicyEnforcer garandeert die volgorde.
verify() retourneert de ondertekenaars-PEM alleen wanneer de digest- en handtekeningcontrole kloppen onder het vaste profiel en de ondertekenaar ketent, binnen diepte 8 en met elke schakel temporeel geldig, naar een geconfigureerde anchor.
De enforcer wijst elke lijst af waarvan NextUpdate is verstreken op de huidige klok; buildBundle() bevestigt de versheid opnieuw op het door de aanroeper aangeleverde moment voordat het anchors afleidt.
Anchors worden uitsluitend afgeleid uit diensten in granted-status met het CA/QC-diensttype; een lege actieve set gooit in plaats van een lege bundel op te leveren.
Elke fout is een getypeerde exception (TslFetchException, NetworkPolicyViolation, TslSignatureException met een reason code, TslParseException); geen enkele methode retourneert een gedeeltelijk of ongeverifieerd document.

Core-terugval

NextPDF Core valideert PDF-handtekeningen tegen trust anchors die je expliciet vastpint via zijn CaTrustAnchorBundle-contract — zie Core-beveiliging. Core heeft geen trusted-list-functionaliteit: geen TSL-ophalen, geen XMLDSig-lijstauthenticatie, geen ETSI TS 119 612-parsing, en geen anchorafleiding uit gekwalificeerde-dienstentries. Met Core alleen onderhoud je je anchorset met de hand; het afleiden ervan uit geauthenticeerde EU trusted lists vereist NextPDF Enterprise.

Publicatiegrens

Deze pagina documenteert uitsluitend extern waarneembaar gedrag en het ondersteunde publieke API-oppervlak. Interne namespace-paden, hulpklassen, mechanismetabellen, runbook-bestandsnamen en ticketprefixen vallen buiten de scope.

Zie ook

ASiC trust binding — bindt containerondertekenaars aan de anchorbundels die deze pagina afleidt.
eIDAS-betrouwbaarheidsniveaus — brengt TspService-bewijs in kaart op Levels of Assurance.
Handtekeningverificatie — de verificatiezijde die trust anchors consumeert voor padvalidatie.
Beveiliging — diepgaande referentie — de contractniveau-referentie van de Enterprise-beveiligingsmodule.
Gekwalificeerde handtekeningen, uitgelegd — waarom trusted lists het EU-vertrouwensmodel verankeren.
Langetermijnvalidatie — waarom validatietijd en bewaard bewijs ertoe doen.