Enterprise edizione

Elenchi di fiducia (TSL)

In sintesi

La validazione delle firme UE parte da un fatto pubblicato: quali provider detengono lo stato qualificato. Quel fatto risiede negli elenchi di fiducia (TSL) — documenti XML firmati che ogni Stato membro pubblica, indicizzati dall’elenco degli elenchi di fiducia (LOTL) dell’UE. NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer trasforma un URL di TSL o XML grezzo in un TslDocument su cui si può fare affidamento. Effettua il fetch su HTTPS protetto, verifica la firma XMLDSig contro le ancore fissate, esegue il parsing dell’XML irrobustito e rifiuta gli elenchi obsoleti. Un’ulteriore chiamata, TslTrustAnchorProvider::buildBundle(), converte i servizi CA/QC attivi in un bundle di ancore di fiducia versionato. Ogni gate fallisce in modo chiuso; ogni rifiuto è un’eccezione tipizzata.

Questa pagina è responsabile dell’acquisizione degli elenchi e della derivazione delle ancore. La validazione del percorso di certificazione risiede in Verifica delle firme. Il mapping dei livelli di garanzia eIDAS risiede in Livelli di garanzia eIDAS. Il binding di fiducia dei contenitori risiede in Binding di fiducia ASiC.

Disponibilità e licenza

Questa capacità è inclusa in NextPDF Enterprise (nextpdf/enterprise) e si attiva con un envelope di licenza di livello Enterprise. Un deployment privo di tale titolo non carica le classi della capacità. Confronta le edizioni e ottieni una licenza.

Installazione

composer require nextpdf/enterprise

L’attivazione richiede il tuo envelope di licenza Enterprise. Vedi Installazione e autenticazione. Le classi di questa pagina risiedono in NextPDF\Enterprise\Security\Tsl; i tipi della policy di rete risiedono in NextPDF\Enterprise\Security. Il fetch online richiede inoltre un qualsiasi client PSR-18 e una factory PSR-17 (per esempio guzzlehttp/guzzle).

Panoramica concettuale

Ai sensi dell’articolo 22 di eIDAS, ogni Stato membro pubblica un elenco di fiducia dei propri prestatori di servizi fiduciari qualificati, firmato o sigillato per l’elaborazione automatica. ETSI TS 119 612 definisce il formato XML. L’elenco è affidabile solo quanto lo rendono tre controlli: la sua firma, la sua struttura e la sua freschezza. NextPDF li esegue in quest’ordine, come un’unica pipeline:

Fetch — TslFetcher recupera l’XML esclusivamente su HTTPS. Una protezione SSRF valida l’host prima di qualsiasi egress. Le risposte hanno un limite di dimensione, e una cache PSR-16 abilita la rivalidazione ETag e le letture air-gapped.
Verify — TslSignatureVerifier controlla la firma XMLDSig enveloped. Il certificato di firma deve concatenarsi a un’ancora di fiducia fissata out-of-band; nulla all’interno del documento è ritenuto affidabile di per sé.
Parse — TslXmlParser estrae le informazioni sullo schema e ogni servizio TSP in un TslDocument immutabile. I documenti che recano un DOCTYPE vengono rifiutati prima che venga costruita qualsiasi tabella di entità.
Enforce — l’istante NextUpdate dell’elenco non deve essere già trascorso. Un elenco obsoleto viene scartato, mai consumato.

TslPolicyEnforcer compone tutti e quattro; un TslDocument da esso prodotto ha superato ogni gate. Da lì, TslTrustAnchorProvider::buildBundle() filtra i servizi che sono sia in stato granted sia di tipo CA/QC, ed emette un EnterpriseCaTrustAnchorBundle: ancore PEM fissate, una versione tsl-<territory>-seq<N> e un digest di integrità SHA-256. Quel bundle è ciò che consumano la validazione del percorso e il binding di fiducia ASiC.

Lo stesso meccanismo copre il workflow LOTL. Verifica la LOTL contro un’ancora fissata manualmente; poi verifica ogni TSL di uno Stato membro contro i certificati di firma che la LOTL dichiara per essa.

Perché funziona così

La decisione portante è un profilo di verifica fisso e minimale invece di XMLDSig generico. L’elaborazione flessibile delle firme XML — catene di trasformazioni arbitrarie, riferimenti a ID dichiarati dall’attaccante, agilità algoritmica — è il punto in cui storicamente i verificatori si rompono. Perciò il verificatore accetta esattamente un solo modello di elaborazione: C14N esclusiva, un riferimento che copre la radice e la pipeline a due trasformazioni [enveloped-signature, exclusive-C14N], con tutto il resto rifiutato in modo chiuso. La fiducia non viene mai avviata dal documento stesso: i certificati di KeyInfo si concatenano soltanto alle ancore che hai configurato. La freschezza risiede su TslDocument stesso, così che ogni percorso consumatore la applichi anziché affidarla a un singolo collaboratore facoltativo. Il risultato è un piccolo kernel testabile, deterministico e onesto su ciò che rifiuta.

Contesto progettuale: Firme qualificate, spiegate.

Superficie API

`TslPolicyEnforcer`

Il punto di ingresso orchestrato: fetch, verifica, parsing e controllo di freschezza in una sola chiamata.

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

Lancia o fallisce con: TslFetchException e NextPDF\Enterprise\Security\NetworkPolicyViolation dalla fase di fetch; TslSignatureException dalla verifica della firma; TslParseException dal parsing, da un valore NextUpdate non canonico o da un elenco obsoleto. Entrambi i metodi restituiscono un TslDocument solo quando ogni gate è stato superato. Il gate di obsolescenza qui confronta NextUpdate con l’orologio di sistema corrente.

`TslFetcher`

Fetcher HTTP con caching basato su ETag e un gate di policy di rete.

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

Lancia o fallisce con: TslFetchException su un URL non HTTPS, un host rifiutato (SSRF), uno stato HTTP di errore, una risposta sovradimensionata o un corpo vuoto; NetworkPolicyViolation quando NetworkPolicy::STRICT_OFFLINE è attiva e non esiste alcun corpo in cache. I corpi in cache soddisfano la rivalidazione 304 Not Modified e sono gli unici corpi serviti sotto STRICT_OFFLINE. Le voci di cache vivono per $defaultTtlSeconds.

`TslSignatureVerifier`

Verificatore XMLDSig per elenchi di fiducia firmati.

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

public function verify(string $xml): string

verify() restituisce il PEM del certificato di firma, dimostrato concatenarsi a uno di $trustAnchorsPem. Il costruttore lancia InvalidArgumentException quando l’elenco di ancore è vuoto. $clockTolerance allarga simmetricamente la finestra di validità del certificato, in secondi.

Il profilo accettato è fisso. Algoritmi di firma: l’allowlist ALLOWED_SIG_ALG (rsa-sha256/384/512, ecdsa-sha256/384/512). Digest: l’allowlist ALLOWED_DIGEST_ALG (SHA-256, SHA-384, SHA-512). Canonicalizzazione: solo C14N esclusiva 1.0. SHA-1 e MD5 vengono rifiutati come unsupported_algorithm.

Lancia o fallisce con: TslSignatureException, che reca un reason leggibile dalla macchina:

Codice reason	Significato
`missing_signature`	Il documento non ha alcun elemento `ds:Signature`.
`untrusted_signer`	Il certificato di `KeyInfo` non si concatena a un’ancora configurata.
`invalid_signature`	Difetto strutturale, oppure il controllo RSA/ECDSA è fallito.
`digest_mismatch`	Il digest del riferimento non corrisponde al documento canonicalizzato.
`unsupported_algorithm`	Algoritmo di firma o di digest al di fuori dell’allowlist.
`unsupported_transform`	Pipeline di canonicalizzazione o di trasformazione al di fuori del profilo fisso.
`expired_anchor`	Un certificato della catena è al di fuori della sua finestra di validità, oppure la sua validità non è analizzabile.

`TslXmlParser`

Parser strutturale agnostico rispetto alla firma. I chiamanti DEVONO verificare prima di fidarsi del suo output; TslPolicyEnforcer impone quell’ordine al posto tuo.

public function parse(string $xml): TslDocument

Lancia o fallisce con: TslParseException quando l’XML dichiara un DOCTYPE (irrobustimento contro XXE ed espansione di entità), non può essere analizzato, manca della radice TrustServiceStatusList, o reca un TSLSequenceNumber non valido. La classe espone le costanti di namespace NS_TSL, NS_DSIG e NS_TSL_X.

`TslDocument` e `TspService`

TslDocument è un value object immutabile: schemeTerritory, schemeOperatorName, tslType, sequenceNumber, issueDateTime, nextUpdate, tspServices e rawXmlSha256 (hash di evidenza sui byte grezzi).

public function isStale(DateTimeImmutable $now): bool

public function assertFresh(DateTimeImmutable $now): void

public function servicesOfType(string $serviceTypeIdentifier): array

public function activeServices(): array

Lancia o fallisce con: isStale() e assertFresh() lanciano TslParseException quando nextUpdate non è un dateTime UTC canonico con un Z esplicito o un offset numerico; un elenco obsoleto fa lanciare assertFresh(). activeServices() restituisce solo i servizi in stato granted. servicesOfType() filtra per URI di tipo di servizio ETSI.

Ogni voce TspService espone tspName, serviceName, serviceTypeIdentifier, serviceStatus, statusStartingTime, serviceCertificatePem, qualifiers e additionalServiceInformation, oltre a:

public function isGranted(): bool

public function isQualifiedCa(): bool

Costanti utili: TspService::STATUS_GRANTED, TspService::STATUS_WITHDRAWN, TspService::TYPE_CA_QC, TspService::TYPE_OCSP_QC, TspService::TYPE_TSA_QTST. Gli URI di qualificatore (per esempio TspServiceQualifier::FOR_ESIG, FOR_ESEAL, QSCD_STATEMENT, NO_QSCD) emergono su TspServiceQualifier per il livello di mapping eIDAS.

`TslTrustAnchorProvider` e il bundle di ancore

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

Lancia o fallisce con: TslParseException quando la TSL è obsoleta a $now, quando nextUpdate non è un valore UTC canonico, o quando l’elenco non contiene alcun servizio CA/QC attivo.

Nota BC — la regola di freschezza di buildBundle($now). buildBundle() richiede l’istante di validazione e chiama TslDocument::assertFresh($now) prima di estrarre una singola ancora. Le revisioni precedenti potevano derivare ancore da un TslDocument prodotto dal parser senza alcun controllo di freschezza. I chiamanti che fornivano elenchi in cache o archiviati devono ora passare l’istante in cui la loro validazione viene eseguita; un elenco obsoleto a quell’istante lancia invece di seminare silenziosamente le ancore di fiducia.

L’EnterpriseCaTrustAnchorBundle restituito è un value object di sola lettura: anchorsPem (le ancore PEM), bundleVersion (tsl-<territory>-seq<N>) e bundleSha256 (digest di integrità sulla concatenazione PEM canonicalizzata). Ottienilo da buildBundle(); non costruirlo a mano — il costruttore lancia InvalidArgumentException in caso di mismatch del digest o di PEM malformato.

public function containsFingerprint(string $anchorDerSha256Hex): bool

public static function computeBundleSha256(array $anchorsPem): string

Esempio di codice — Avvio rapido

Autentica e consuma un elenco di fiducia mirrorato localmente. Per questo percorso non è necessaria alcuna dipendenza HTTP: verifica, esegui il parsing, poi applica il gate di freschezza al tuo istante di validazione.

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

Output atteso (i valori variano in base all’elenco):

Territory: DE
Sequence: 127
Active services: 143

Esempio di codice — Produzione

Collega l’intera pipeline online: fetch protetto con caching, verifica della firma, parsing, freschezza, poi derivazione del bundle di ancore. Ogni classe di errore viene catturata e riportata in modo distinto.

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

Output atteso (i valori variano in base all’elenco):

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

Registra bundleVersion e bundleSha256 con ogni validazione che esegui contro il bundle. Essi nominano l’esatto insieme di ancore dietro ciascun verdetto.

Casi limite e insidie

Il gate di freschezza dell’enforcer usa l’orologio corrente. fetchAndVerify() e verifyXml() rifiutano un elenco il cui NextUpdate è già trascorso. Per una validazione storica contro un elenco archiviato, pilota direttamente TslSignatureVerifier e TslXmlParser, poi chiama assertFresh() con l’istante passato che le tue evidenze supportano.
buildBundle() riafferma la freschezza al tuo $now. Un elenco che ha superato l’enforcer può comunque essere rifiutato qui se il tuo istante di validazione è successivo. Vedi la nota BC sopra.
Non seminare mai trustAnchorsPem dall’elenco che stai verificando. L’ancora deve provenire da una fonte fissata out-of-band (per la LOTL) o da un elenco padre già verificato (per le TSL degli Stati membri). Qualsiasi altra cosa rende la verifica circolare.
Un DOCTYPE ovunque è fatale. Le TSL conformi non recano mai una DTD, quindi il parser rifiuta qualsiasi DOCTYPE prima che libxml costruisca una tabella di entità. Questo è un irrobustimento intenzionale, non un limite del parser.
I campi strutturali mancanti degradano in modo sicuro. Un servizio privo di uno stato leggibile viene trattato come withdrawn, così da non poter mai diventare un’ancora. Un territorio di schema mancante viene analizzato come unknown. I default fail-closed tengono le voci malformate fuori dal materiale di fiducia.
Gli intermediari devono essere vere CA. Durante la costruzione della catena, un emittente candidato privo di basicConstraints cA=TRUE (o che asserisce keyUsage senza keyCertSign) viene saltato. Un certificato di entità finale infilato in KeyInfo non può fungere da intermediario del percorso. Le catene sono limitate a una profondità di 8.
NextUpdate deve essere UTC canonico. Un valore privo di un Z esplicito o di un offset numerico lancia TslParseException. Non viene mai reinterpretato nel fuso orario locale del server.
Elenchi di grandi dimensioni e il limite di byte. Le risposte vengono lette fino a $maxBytes (default 16 MiB). Aumenta il limite nel costruttore se l’elenco del tuo schema è più grande; il troncamento emerge come un fallimento di firma, mai come un’accettazione silenziosa.
clockTolerance amplia soltanto. Aggiunge un margine simmetrico ai controlli di validità del certificato. Non allenta il gate di freschezza a livello di elenco.

Note di sicurezza

Verifica prima del parsing, sempre. TslXmlParser è agnostico rispetto alla firma per progettazione. TslPolicyEnforcer ordina la verifica per prima; se componi i pezzi da solo, mantieni quell’ordine.
Difesa SSRF in profondità. fetch() richiede https:// e valida l’host contro gli intervalli privati, di loopback, link-local, CGN e di metadati cloud, con risoluzione DNS A e AAAA per mitigare il rebinding. Un URL rifiutato lancia prima di qualsiasi egress.
Irrobustimento contro XXE ed espansione di entità. I documenti che recano un DOCTYPE vengono rifiutati prima che la tabella di entità esista e di nuovo dopo il caricamento. Il caricamento di entità di rete è disabilitato; le entità esterne non vengono mai sostituite.
Profilo XMLDSig rigoroso. Solo C14N esclusiva; esattamente la coppia di trasformazioni [enveloped-signature, exclusive-C14N]; il riferimento verificato deve coprire la radice del documento; la trasformazione enveloped rimuove solo la firma verificata, preservando le firme fratelle. Gli algoritmi deprecati (SHA-1, MD5) vengono rifiutati.
Disciplina di catena. Ogni anello della catena — firmatario, intermediari e il caso di ancora diretta — viene controllato per la validità temporale, fail-closed su limiti di validità non analizzabili. I loop vengono rilevati; la profondità è limitata.
Postura air-gap. Sotto NetworkPolicy::STRICT_OFFLINE, il percorso di fetch non esegue alcun egress in uscita; solo un corpo precedentemente in cache può essere servito, e qualsiasi altra cosa lancia NetworkPolicyViolation fail-fast.
I digest del bundle rilevano la corruzione, non la manomissione. bundleSha256 viene validato alla costruzione e rileva la deriva di trascrizione. Quando il digest è derivato dalle stesse ancore che protegge, non costituisce un’evidenza di manomissione indipendente. Fissa i digest out-of-band quando trasporti i bundle tra sistemi.

Conformità

La pipeline consuma gli elenchi di fiducia come li definisce ETSI TS 119 612: autentica la firma dell’operatore dello schema (§5.7), esegue il parsing delle strutture delle informazioni sullo schema e dell’elenco dei provider (§5.3, §5.4, §5.5), applica le regole del dateTime UTC (§5.1.3) e scarta gli elenchi il cui NextUpdate è trascorso (§5.3.15). Ciò supporta il modello dell’articolo 22 di eIDAS di elenchi di fiducia firmati e processabili dalla macchina. La costruzione della catena applica i gate di basic-constraints e key-usage di RFC 5280 agli emittenti candidati.

Il supporto non è conformità, e la conformità non è certificazione. NextPDF implementa i controlli che questa pagina descrive; non è stato certificato rispetto a ETSI TS 119 612, eIDAS o qualsiasi altro standard da alcun ente, e NextPDF non detiene alcuna certificazione e non ne concede alcuna. Consumare un elenco di fiducia attraverso questa API non rende di per sé una firma “qualificata” o giuridicamente efficace. Se il tuo processo di validazione completo soddisfi un requisito legale o di appalto è una determinazione spettante ai tuoi valutatori.

Comportamento in modalità FIPS

La verifica della firma TSL esegue i controlli RSA ed ECDSA in-process attraverso la libreria crittografica inclusa. Non viene instradata attraverso il runtime guard della modalità FIPS Enterprise, e l’abilitazione della modalità FIPS non ne modifica il comportamento. Non è un servizio crittografico validato FIPS, e non viene rivendicata alcuna certificazione FIPS 140. I deployment con obblighi FIPS dovrebbero delimitare questa API di conseguenza e consultare Policy crittografica FIPS 140-2/3.

Contratto di comportamento

fetch() esegue egress solo per URL HTTPS che superano la validazione SSRF, legge al massimo $maxBytes e onora la NetworkPolicy configurata; sotto STRICT_OFFLINE viene restituito solo un corpo in cache.
Nessun output del parser diventa materiale di fiducia prima che verify() abbia successo; TslPolicyEnforcer garantisce quell’ordine.
verify() restituisce il PEM del firmatario solo quando il controllo di digest e firma è valido sotto il profilo fisso e il firmatario si concatena, entro una profondità di 8 e con ogni anello temporalmente valido, a un’ancora configurata.
L’enforcer rifiuta qualsiasi elenco il cui NextUpdate sia trascorso all’orologio corrente; buildBundle() riafferma la freschezza all’istante fornito dal chiamante prima di derivare le ancore.
Le ancore derivano esclusivamente da servizi in stato granted con il tipo di servizio CA/QC; un insieme attivo vuoto lancia invece di produrre un bundle vuoto.
Ogni fallimento è un’eccezione tipizzata (TslFetchException, NetworkPolicyViolation, TslSignatureException con un codice reason, TslParseException); nessun metodo restituisce un documento parziale o non verificato.

Ripiego su Core

NextPDF Core valida le firme PDF contro le ancore di fiducia che fissi esplicitamente tramite il suo contratto CaTrustAnchorBundle — vedi Sicurezza di Core. Core non ha alcuna capacità di elenchi di fiducia: nessun fetch di TSL, nessuna autenticazione XMLDSig di elenchi, nessun parsing ETSI TS 119 612 e nessuna derivazione di ancore da voci di servizio qualificato. Con Core da solo mantieni il tuo insieme di ancore a mano; derivarlo da elenchi di fiducia UE autenticati richiede NextPDF Enterprise.

Confine di pubblicazione

Questa pagina documenta esclusivamente il comportamento osservabile esternamente e la superficie API pubblica supportata. I percorsi di namespace interni, le classi helper, le tabelle di meccanismi, i nomi di file dei runbook e i prefissi dei ticket sono fuori ambito.

Vedi anche

Binding di fiducia ASiC — lega i firmatari dei contenitori ai bundle di ancore che questa pagina deriva.
Livelli di garanzia eIDAS — mappa le evidenze di TspService ai livelli di garanzia.
Verifica delle firme — il lato di verifica che consuma le ancore di fiducia per la validazione del percorso.
Sicurezza — riferimento approfondito — il riferimento a livello di contratto del modulo di sicurezza Enterprise.
Firme qualificate, spiegate — perché gli elenchi di fiducia ancorano il modello di fiducia UE.
Validazione a lungo termine — perché il tempo di validazione e le evidenze conservate contano.