Enterprise edycja

Zaufane listy (TSL)

W skrócie

Unijna walidacja podpisów zaczyna się od opublikowanego faktu: którzy dostawcy posiadają status kwalifikowany. Fakt ten żyje w zaufanych listach (TSL) — podpisanych dokumentach XML, które publikuje każde państwo członkowskie, indeksowanych przez unijną listę zaufanych list (LOTL). NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer zamienia adres URL listy TSL lub surowy XML w TslDocument, na którym można polegać. Pobiera go po zabezpieczonym HTTPS, weryfikuje podpis XMLDSig względem przypiętych przez Ciebie kotwic, parsuje wzmocniony XML i odrzuca nieaktualne listy. Jedno kolejne wywołanie, TslTrustAnchorProvider::buildBundle(), przekształca aktywne usługi CA/QC w wersjonowany pakiet kotwic zaufania. Każda bramka działa w trybie fail-closed; każde odrzucenie to typowany wyjątek.

Ta strona odpowiada za przetwarzanie list i wyprowadzanie kotwic. Walidacja ścieżki certyfikacji opisana jest w Weryfikacja podpisu. Mapowanie poziomów wiarygodności eIDAS opisano w Poziomy wiarygodności eIDAS. Wiązanie zaufania kontenerów opisano w Wiązanie zaufania ASiC.

Dostępność i licencjonowanie

Ta funkcja jest dostarczana w NextPDF Enterprise (nextpdf/enterprise) i aktywuje się z kopertą licencyjną w edycji Enterprise. Wdrożenie bez tego uprawnienia nie ładuje klas tej funkcji. Porównaj edycje i uzyskaj licencję.

Instalacja

composer require nextpdf/enterprise

Aktywacja wymaga koperty licencyjnej Enterprise. Zobacz Instalacja i uwierzytelnianie. Klasy z tej strony znajdują się w przestrzeni NextPDF\Enterprise\Security\Tsl; typy polityki sieciowej znajdują się w przestrzeni NextPDF\Enterprise\Security. Pobieranie online dodatkowo wymaga dowolnego klienta PSR-18 i fabryki PSR-17 (na przykład guzzlehttp/guzzle).

Przegląd koncepcyjny

Zgodnie z artykułem 22 eIDAS każde państwo członkowskie publikuje zaufaną listę swoich kwalifikowanych dostawców usług zaufania, podpisaną lub opieczętowaną do automatycznego przetwarzania. ETSI TS 119 612 definiuje format XML. Lista jest tak wiarygodna, jak wiarygodne czynią ją trzy kontrole: jej podpis, jej struktura i jej świeżość. NextPDF wykonuje je w tej kolejności, jako jeden potok:

Pobranie — TslFetcher pobiera XML wyłącznie po HTTPS. Zabezpieczenie przed SSRF waliduje hosta przed jakimkolwiek wyjściem na zewnątrz. Odpowiedzi mają ograniczony rozmiar, a pamięć podręczna PSR-16 umożliwia ponowną walidację ETag oraz odczyty w trybie odizolowanym od sieci.
Weryfikacja — TslSignatureVerifier sprawdza obejmujący podpis XMLDSig. Certyfikat podpisujący musi tworzyć łańcuch do kotwicy zaufania przypiętej przez Ciebie poza pasmem; nic wewnątrz dokumentu nie jest samodzielnie zaufane.
Parsowanie — TslXmlParser wyodrębnia informacje o schemacie oraz każdą usługę TSP do niezmiennego TslDocument. Dokumenty zawierające DOCTYPE są odrzucane przed zbudowaniem jakiejkolwiek tablicy encji.
Egzekwowanie — moment NextUpdate listy nie może być przekroczony. Nieaktualna lista jest odrzucana, nigdy nie konsumowana.

TslPolicyEnforcer łączy wszystkie cztery kroki; TslDocument pochodzący z niego przeszedł każdą bramkę. Stamtąd TslTrustAnchorProvider::buildBundle() filtruje usługi, które są jednocześnie w statusie granted i typu CA/QC, i emituje EnterpriseCaTrustAnchorBundle: przypięte kotwice PEM, wersję tsl-<territory>-seq<N> oraz skrót integralności SHA-256. Ten pakiet jest tym, co konsumuje walidacja ścieżki i wiązanie zaufania ASiC.

Ta sama maszyneria obejmuje proces LOTL. Zweryfikuj LOTL względem ręcznie przypiętej kotwicy; następnie zweryfikuj każdą listę TSL państwa członkowskiego względem certyfikatów podpisujących, które LOTL dla niej deklaruje.

Dlaczego działa to w ten sposób

Nośną decyzją jest ustalony, minimalny profil weryfikacji zamiast ogólnego XMLDSig. Elastyczne przetwarzanie podpisów XML — dowolne łańcuchy przekształceń, deklarowane przez atakującego referencje ID, elastyczność algorytmów — to miejsce, w którym weryfikatory historycznie się załamują. Dlatego weryfikator akceptuje dokładnie jeden model przetwarzania: exclusive C14N, referencję obejmującą korzeń oraz dwuprzekształceniowy potok [enveloped-signature, exclusive-C14N], przy czym wszystko inne jest odrzucane w trybie fail-closed. Zaufanie nigdy nie bootstrappuje się z samego dokumentu: certyfikaty KeyInfo zawsze tworzą łańcuch wyłącznie do skonfigurowanych przez Ciebie kotwic. Świeżość żyje na samym TslDocument, więc każda ścieżka konsumenta ją egzekwuje, a nie jeden opcjonalny współpracownik. Rezultatem jest małe jądro, które jest testowalne, deterministyczne i uczciwe co do tego, czego odmawia.

Tło projektowe: Podpisy kwalifikowane — wyjaśnienie.

Powierzchnia API

`TslPolicyEnforcer`

Zorkiestrowany punkt wejścia: pobranie, weryfikacja, parsowanie i kontrola świeżości w jednym wywołaniu.

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

Zgłasza lub kończy się niepowodzeniem przez: TslFetchException i NextPDF\Enterprise\Security\NetworkPolicyViolation z etapu pobierania; TslSignatureException z weryfikacji podpisu; TslParseException z parsowania, z niekanonicznej wartości NextUpdate lub z nieaktualnej listy. Obie metody zwracają TslDocument tylko wtedy, gdy każda bramka została przejścia. Bramka nieaktualności porównuje tutaj NextUpdate z bieżącym zegarem systemowym.

`TslFetcher`

Fetcher HTTP z buforowaniem opartym na ETag i bramką polityki sieciowej.

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

Zgłasza lub kończy się niepowodzeniem przez: TslFetchException przy adresie URL innym niż HTTPS, odrzuconym (SSRF) hoście, statusie błędu HTTP, zbyt dużej odpowiedzi lub pustym ciele; NetworkPolicyViolation, gdy aktywne jest NetworkPolicy::STRICT_OFFLINE i nie istnieje żadne buforowane ciało. Buforowane ciała spełniają ponowną walidację 304 Not Modified i są jedynymi ciałami obsługiwanymi w trybie STRICT_OFFLINE. Wpisy pamięci podręcznej żyją przez $defaultTtlSeconds.

`TslSignatureVerifier`

Weryfikator XMLDSig dla podpisanych zaufanych list.

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

public function verify(string $xml): string

verify() zwraca PEM certyfikatu podpisującego, z udowodnionym łańcuchem do jednej z $trustAnchorsPem. Konstruktor zgłasza InvalidArgumentException, gdy lista kotwic jest pusta. $clockTolerance symetrycznie rozszerza okno ważności certyfikatu, w sekundach.

Akceptowany profil jest ustalony. Algorytmy podpisu: lista dozwolonych ALLOWED_SIG_ALG (rsa-sha256/384/512, ecdsa-sha256/384/512). Skróty: lista dozwolonych ALLOWED_DIGEST_ALG (SHA-256, SHA-384, SHA-512). Kanonizacja: wyłącznie exclusive C14N 1.0. SHA-1 i MD5 są odrzucane jako unsupported_algorithm.

Zgłasza lub kończy się niepowodzeniem przez: TslSignatureException, niosący czytelny maszynowo reason:

Kod przyczyny	Znaczenie
`missing_signature`	Dokument nie ma elementu `ds:Signature`.
`untrusted_signer`	Certyfikat `KeyInfo` nie tworzy łańcucha do skonfigurowanej kotwicy.
`invalid_signature`	Defekt strukturalny lub kontrola RSA/ECDSA nie powiodła się.
`digest_mismatch`	Skrót referencji nie zgadza się z kanonizowanym dokumentem.
`unsupported_algorithm`	Algorytm podpisu lub skrótu spoza listy dozwolonych.
`unsupported_transform`	Potok kanonizacji lub przekształceń spoza ustalonego profilu.
`expired_anchor`	Certyfikat łańcucha jest poza swoim oknem ważności lub jego ważność jest nieparsowalna.

`TslXmlParser`

Parser strukturalny niezależny od podpisu. Wywołujący MUSZĄ zweryfikować przed zaufaniem jego wynikom; TslPolicyEnforcer egzekwuje tę kolejność za Ciebie.

public function parse(string $xml): TslDocument

Zgłasza lub kończy się niepowodzeniem przez: TslParseException, gdy XML deklaruje DOCTYPE (wzmocnienie przeciw XXE i rozwinięciu encji), nie może zostać sparsowany, nie posiada korzenia TrustServiceStatusList lub niesie nieprawidłowy TSLSequenceNumber. Klasa udostępnia stałe przestrzeni nazw NS_TSL, NS_DSIG oraz NS_TSL_X.

`TslDocument` i `TspService`

TslDocument to niezmienny obiekt wartości: schemeTerritory, schemeOperatorName, tslType, sequenceNumber, issueDateTime, nextUpdate, tspServices oraz rawXmlSha256 (skrót dowodowy nad surowymi bajtami).

public function isStale(DateTimeImmutable $now): bool

public function assertFresh(DateTimeImmutable $now): void

public function servicesOfType(string $serviceTypeIdentifier): array

public function activeServices(): array

Zgłasza lub kończy się niepowodzeniem przez: isStale() i assertFresh() zgłaszają TslParseException, gdy nextUpdate nie jest kanonicznym dateTime UTC z jawnym Z lub przesunięciem numerycznym; nieaktualna lista sprawia, że assertFresh() zgłasza wyjątek. activeServices() zwraca tylko usługi w statusie granted. servicesOfType() filtruje według identyfikatora URI typu usługi ETSI.

Każdy wpis TspService udostępnia tspName, serviceName, serviceTypeIdentifier, serviceStatus, statusStartingTime, serviceCertificatePem, qualifiers oraz additionalServiceInformation, a ponadto:

public function isGranted(): bool

public function isQualifiedCa(): bool

Przydatne stałe: TspService::STATUS_GRANTED, TspService::STATUS_WITHDRAWN, TspService::TYPE_CA_QC, TspService::TYPE_OCSP_QC, TspService::TYPE_TSA_QTST. Identyfikatory URI kwalifikatorów (na przykład TspServiceQualifier::FOR_ESIG, FOR_ESEAL, QSCD_STATEMENT, NO_QSCD) pojawiają się na TspServiceQualifier dla warstwy mapowania eIDAS.

`TslTrustAnchorProvider` i pakiet kotwic

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

Zgłasza lub kończy się niepowodzeniem przez: TslParseException, gdy TSL jest nieaktualny w $now, gdy nextUpdate nie jest kanoniczną wartością UTC lub gdy lista nie zawiera żadnych aktywnych usług CA/QC.

Uwaga BC — reguła świeżości buildBundle($now). buildBundle() wymaga momentu walidacji i wywołuje TslDocument::assertFresh($now) przed wyodrębnieniem choćby jednej kotwicy. Wcześniejsze wersje mogły wyprowadzać kotwice z TslDocument wyprodukowanego przez parser bez jakiejkolwiek kontroli świeżości. Wywołujący, którzy podawali buforowane lub zarchiwizowane listy, muszą teraz przekazać moment, w którym uruchamia się ich walidacja; lista nieaktualna w tym momencie zgłasza wyjątek, zamiast po cichu zasiewać kotwice zaufania.

Zwrócony EnterpriseCaTrustAnchorBundle to obiekt wartości tylko do odczytu: anchorsPem (kotwice PEM), bundleVersion (tsl-<territory>-seq<N>) oraz bundleSha256 (skrót integralności nad kanonizowaną konkatenacją PEM). Uzyskaj go z buildBundle(); nie konstruuj go ręcznie — konstruktor zgłasza InvalidArgumentException przy niezgodności skrótu lub zniekształconym PEM.

public function containsFingerprint(string $anchorDerSha256Hex): bool

public static function computeBundleSha256(array $anchorsPem): string

Przykład kodu — Szybki start

Uwierzytelnij i skonsumuj lokalnie zreplikowaną zaufaną listę. Ta ścieżka nie wymaga zależności HTTP: zweryfikuj, sparsuj, następnie zbramkuj świeżość w Twoim momencie walidacji.

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

Oczekiwane wyjście (wartości zależą od listy):

Territory: DE
Sequence: 127
Active services: 143

Przykład kodu — Produkcja

Podłącz pełny potok online: zabezpieczone pobranie z buforowaniem, weryfikacja podpisu, parsowanie, świeżość, następnie wyprowadzenie pakietu kotwic. Każda klasa awarii jest przechwytywana i raportowana osobno.

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

Oczekiwane wyjście (wartości zależą od listy):

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

Zapisuj bundleVersion i bundleSha256 przy każdej walidacji, którą wykonujesz względem pakietu. Nazywają one dokładny zbiór kotwic stojący za każdym werdyktem.

Przypadki brzegowe i pułapki

Bramka świeżości egzekutora używa bieżącego zegara. fetchAndVerify() i verifyXml() odrzucają listę, której NextUpdate już minął. Do walidacji historycznej względem zarchiwizowanej listy steruj TslSignatureVerifier i TslXmlParser bezpośrednio, a następnie wywołaj assertFresh() z minionym momentem, który potwierdza Twój dowód.
buildBundle() ponownie potwierdza świeżość w Twoim $now. Lista, która przeszła przez egzekutor, może wciąż zostać tu odrzucona, jeśli Twój moment walidacji jest późniejszy. Zobacz uwagę BC powyżej.
Nigdy nie zasiewaj trustAnchorsPem z listy, którą weryfikujesz. Kotwica musi pochodzić z przypiętego źródła poza pasmem (dla LOTL) lub z już zweryfikowanej listy nadrzędnej (dla list TSL państw członkowskich). Cokolwiek innego czyni weryfikację cykliczną.
DOCTYPE gdziekolwiek jest fatalny. Zgodne z normą listy TSL nigdy nie niosą DTD, więc parser odrzuca każdy DOCTYPE, zanim libxml zbuduje tablicę encji. To celowe wzmocnienie, nie ograniczenie parsera.
Brakujące pola strukturalne degradują się bezpiecznie. Usługa bez czytelnego statusu jest traktowana jak wycofana, więc nigdy nie może stać się kotwicą. Brakujące terytorium schematu parsuje się jako unknown. Domyślne wartości fail-closed trzymają zniekształcone wpisy poza materiałem zaufania.
Certyfikaty pośrednie muszą być prawdziwymi CA. Podczas budowania łańcucha kandydat na wystawcę bez basicConstraints cA=TRUE (lub deklarujący keyUsage bez keyCertSign) jest pomijany. Certyfikat podmiotu końcowego przemycony do KeyInfo nie może pełnić roli pośrednika ścieżki. Łańcuchy są ograniczone do głębokości 8.
NextUpdate musi być kanonicznym UTC. Wartość bez jawnego Z lub przesunięcia numerycznego zgłasza TslParseException. Nigdy nie jest reinterpretowana w lokalnej strefie czasowej serwera.
Duże listy i limit bajtów. Odpowiedzi są odczytywane do $maxBytes (domyślnie 16 MiB). Podnieś limit w konstruktorze, jeśli lista Twojego schematu jest większa; obcięcie ujawnia się jako awaria podpisu, nigdy jako ciche zaakceptowanie.
clockTolerance tylko rozszerza. Dodaje symetryczny luz do kontroli ważności certyfikatu. Nie rozluźnia bramki świeżości na poziomie listy.

Uwagi bezpieczeństwa

Weryfikuj przed parsowaniem, zawsze. TslXmlParser jest z założenia niezależny od podpisu. TslPolicyEnforcer ustawia weryfikację jako pierwszą; jeśli sam składasz elementy, zachowaj tę kolejność.
Obrona przed SSRF w głąb. fetch() wymaga https:// i waliduje hosta względem zakresów prywatnych, pętli zwrotnej, link-local, CGN i metadanych chmury, z rozwiązywaniem DNS A i AAAA dla złagodzenia rebindingu. Odrzucony adres URL zgłasza wyjątek przed jakimkolwiek wyjściem na zewnątrz.
Wzmocnienie przeciw XXE i rozwinięciu encji. Dokumenty zawierające DOCTYPE są odrzucane przed istnieniem tablicy encji i ponownie po załadowaniu. Sieciowe ładowanie encji jest wyłączone; encje zewnętrzne nigdy nie są podstawiane.
Ścisły profil XMLDSig. Wyłącznie exclusive C14N; dokładnie para przekształceń [enveloped-signature, exclusive-C14N]; zweryfikowana referencja musi obejmować korzeń dokumentu; przekształcenie enveloped usuwa tylko zweryfikowany podpis, zachowując podpisy rodzeństwa. Przestarzałe algorytmy (SHA-1, MD5) są odrzucane.
Dyscyplina łańcucha. Każde ogniwo łańcucha — podpisujący, pośrednicy oraz przypadek bezpośredniej kotwicy — jest sprawdzane pod kątem ważności czasowej, fail-closed na nieparsowalnych granicach ważności. Pętle są wykrywane; głębokość jest ograniczona.
Postawa odizolowania od sieci. W trybie NetworkPolicy::STRICT_OFFLINE ścieżka pobierania nie wykonuje żadnego wyjścia na zewnątrz; obsłużone może być tylko wcześniej buforowane ciało, a cokolwiek innego zgłasza NetworkPolicyViolation w trybie fail-fast.
Skróty pakietu wykrywają uszkodzenie, nie manipulację. bundleSha256 jest walidowany podczas konstrukcji i wykrywa dryf transkrypcji. Gdy skrót jest wyprowadzony z tych samych kotwic, które chroni, nie jest niezależnym dowodem manipulacji. Przypinaj skróty poza pasmem podczas transportu pakietów między systemami.

Zgodność

Potok konsumuje zaufane listy tak, jak definiuje je ETSI TS 119 612: uwierzytelnia podpis operatora schematu (§5.7), parsuje informacje o schemacie oraz struktury listy dostawców (§5.3, §5.4, §5.5), egzekwuje reguły dateTime UTC (§5.1.3) i odrzuca listy, których NextUpdate minął (§5.3.15). Wspiera to model eIDAS z artykułu 22 podpisanych, przetwarzalnych maszynowo zaufanych list. Budowanie łańcucha stosuje bramki podstawowych ograniczeń i użycia klucza RFC 5280 do kandydatów na wystawców.

Wsparcie to nie zgodność, a zgodność to nie certyfikacja. NextPDF implementuje kontrole opisane na tej stronie; nie został certyfikowany względem ETSI TS 119 612, eIDAS ani żadnej innej normy przez jakikolwiek organ, a NextPDF nie posiada żadnej certyfikacji i żadnej nie udziela. Konsumowanie zaufanej listy przez to API samo w sobie nie czyni podpisu „kwalifikowanym” ani prawnie skutecznym. To, czy Twój kompletny proces walidacji spełnia wymóg prawny lub przetargowy, jest ustaleniem należącym do Twoich audytorów.

Zachowanie w trybie FIPS

Weryfikacja podpisu TSL wykonuje kontrole RSA i ECDSA w procesie, poprzez dołączoną bibliotekę kryptograficzną. Nie jest kierowana przez strażnik trybu FIPS środowiska Enterprise, a włączenie trybu FIPS nie zmienia jej zachowania. Nie jest to usługa kryptograficzna walidowana pod kątem FIPS i nie deklaruje się żadnej certyfikacji FIPS 140. Wdrożenia z obowiązkami FIPS powinny odpowiednio ograniczyć zakres tego API i zobaczyć Polityka kryptograficzna FIPS 140-2/3.

Kontrakt zachowania

fetch() wykonuje wyjście na zewnątrz tylko dla adresów URL HTTPS, które przechodzą walidację SSRF, odczytuje co najwyżej $maxBytes i honoruje skonfigurowaną NetworkPolicy; w trybie STRICT_OFFLINE zwracane jest zawsze tylko buforowane ciało.
Żaden wynik parsera nie staje się materiałem zaufania, zanim verify() się powiedzie; TslPolicyEnforcer gwarantuje tę kolejność.
verify() zwraca PEM podpisującego tylko wtedy, gdy skrót i kontrola podpisu wypadają pomyślnie w ramach ustalonego profilu, a podpisujący tworzy łańcuch, w granicach głębokości 8 i z każdym ogniwem czasowo ważnym, do skonfigurowanej kotwicy.
Egzekutor odrzuca każdą listę, której NextUpdate minął przy bieżącym zegarze; buildBundle() ponownie potwierdza świeżość w momencie podanym przez wywołującego przed wyprowadzeniem kotwic.
Kotwice wyprowadzane są wyłącznie z usług w statusie granted o typie usługi CA/QC; pusty zbiór aktywny zgłasza wyjątek zamiast dawać pusty pakiet.
Każda awaria to typowany wyjątek (TslFetchException, NetworkPolicyViolation, TslSignatureException z kodem przyczyny, TslParseException); żadna metoda nie zwraca częściowego lub niezweryfikowanego dokumentu.

Rozwiązanie zastępcze Core

NextPDF Core waliduje podpisy PDF względem kotwic zaufania, które przypinasz jawnie przez jego kontrakt CaTrustAnchorBundle — zobacz Bezpieczeństwo Core. Core nie ma funkcji zaufanych list: żadnego pobierania TSL, żadnego uwierzytelniania list XMLDSig, żadnego parsowania ETSI TS 119 612 i żadnego wyprowadzania kotwic z wpisów usług kwalifikowanych. Z samym Core utrzymujesz swój zbiór kotwic ręcznie; wyprowadzanie go z uwierzytelnionych unijnych zaufanych list wymaga NextPDF Enterprise.

Granica publikacji

Ta strona dokumentuje wyłącznie zewnętrznie obserwowalne zachowanie oraz wspieraną publiczną powierzchnię API. Wewnętrzne ścieżki przestrzeni nazw, klasy pomocnicze, tabele mechanizmów, nazwy plików runbooków oraz prefiksy zgłoszeń są poza zakresem.

Zobacz też

Wiązanie zaufania ASiC — wiąże podpisujących kontenery z pakietami kotwic wyprowadzanymi przez tę stronę.
Poziomy wiarygodności eIDAS — mapuje dowody TspService na poziomy wiarygodności.
Weryfikacja podpisu — strona weryfikacji, która konsumuje kotwice zaufania do walidacji ścieżki.
Bezpieczeństwo — dogłębne odniesienie — odniesienie na poziomie kontraktu modułu bezpieczeństwa Enterprise.
Podpisy kwalifikowane — wyjaśnienie — dlaczego zaufane listy zakotwiczają unijny model zaufania.
Walidacja długoterminowa — dlaczego czas walidacji i zachowany dowód mają znaczenie.