Trusted list (TSL)

Sekilas pandang

Validasi tanda tangan Uni Eropa berawal dari sebuah fakta yang dipublikasikan: penyedia mana yang menyandang status qualified. Fakta itu tersimpan dalam trusted list (TSL) — dokumen XML bertanda tangan yang diterbitkan setiap Negara Anggota, diindeks oleh list of trusted lists (LOTL) milik UE. NextPDF\Enterprise\Security\Tsl\TslPolicyEnforcer mengubah sebuah URL TSL atau XML mentah menjadi sebuah TslDocument yang dapat Anda andalkan. Ia mengambil melalui HTTPS yang terjaga, memverifikasi tanda tangan XMLDSig terhadap anchor yang Anda pin, mem-parse XML yang dikeraskan, dan menolak list yang sudah usang. Satu panggilan lanjutan, TslTrustAnchorProvider::buildBundle(), mengonversi layanan CA/QC yang aktif menjadi sebuah bundel trust anchor berversi. Setiap gate fail closed; setiap penolakan adalah exception bertipe.

Halaman ini memiliki tanggung jawab atas penyerapan list dan penurunan anchor. Validasi jalur sertifikat berada di Verifikasi tanda tangan. Pemetaan assurance-level eIDAS berada di Level asuransi eIDAS. Pengikatan trust kontainer berada di Pengikatan trust ASiC.

Ketersediaan & lisensi

Kapabilitas ini dikirimkan dalam NextPDF Enterprise (nextpdf/enterprise) dan diaktifkan dengan envelope lisensi tier Enterprise. Sebuah deployment tanpa entitlement tersebut tidak memuat kelas-kelas kapabilitas ini. Bandingkan edisi dan dapatkan lisensi.

Instalasi

composer require nextpdf/enterprise

Aktivasi membutuhkan envelope lisensi Enterprise Anda. Lihat Pasang dan autentikasi. Kelas-kelas pada halaman ini berada di bawah NextPDF\Enterprise\Security\Tsl; tipe-tipe network policy berada di bawah NextPDF\Enterprise\Security. Pengambilan online tambahan membutuhkan sembarang PSR-18 client dan PSR-17 factory (misalnya guzzlehttp/guzzle).

Tinjauan konseptual

Di bawah eIDAS Article 22, setiap Negara Anggota menerbitkan sebuah trusted list dari qualified trust service provider miliknya, ditandatangani atau disegel untuk pemrosesan otomatis. ETSI TS 119 612 mendefinisikan format XML-nya. List tersebut hanya dapat dipercaya sebatas tiga pemeriksaan yang dilakukan: tanda tangannya, strukturnya, dan freshness-nya. NextPDF menjalankannya dalam urutan itu, sebagai satu pipeline:

1. Fetch — TslFetcher mengambil XML melalui HTTPS saja. Sebuah penjaga SSRF memvalidasi host sebelum egress apa pun. Respons dibatasi ukurannya, dan sebuah PSR-16 cache memungkinkan revalidasi ETag dan pembacaan air-gapped.
2. Verify — TslSignatureVerifier memeriksa tanda tangan XMLDSig yang enveloped. Sertifikat penanda-tangan harus berantai ke sebuah trust anchor yang Anda pin secara out-of-band; tidak ada apa pun di dalam dokumen yang dipercaya dengan sendirinya.
3. Parse — TslXmlParser mengekstrak scheme information dan setiap layanan TSP ke dalam sebuah TslDocument yang immutable. Dokumen yang mengandung DOCTYPE ditolak sebelum tabel entity apa pun dibangun.
4. Enforce — instan NextUpdate dari list tidak boleh sudah terlewati. Sebuah list yang usang dibuang, tidak pernah dikonsumsi.

TslPolicyEnforcer menyusun keempatnya; sebuah TslDocument darinya telah lulus setiap gate. Dari situ, TslTrustAnchorProvider::buildBundle() menyaring layanan yang sekaligus berstatus granted dan bertipe CA/QC, lalu memancarkan sebuah EnterpriseCaTrustAnchorBundle: anchor PEM yang dipin, sebuah versi tsl-<territory>-seq<N>, dan sebuah integrity digest SHA-256. Bundel itulah yang dikonsumsi oleh validasi jalur dan pengikatan trust ASiC.

Mesin yang sama menangani alur kerja LOTL. Verifikasi LOTL terhadap sebuah anchor yang dipin secara manual; kemudian verifikasi setiap TSL negara anggota terhadap sertifikat penanda-tangan yang dideklarasikan LOTL untuknya.

Mengapa ia bekerja seperti ini

Keputusan yang menopang adalah sebuah profil verifikasi yang tetap dan minimal alih-alih XMLDSig umum. Pemrosesan tanda tangan XML yang fleksibel — rantai transform sembarang, referensi ID yang dideklarasikan penyerang, agility algoritma — adalah tempat para verifier secara historis jebol. Maka verifier menerima tepat satu model pemrosesan: exclusive C14N, sebuah referensi yang mencakup root, dan pipeline dua-transform [enveloped-signature, exclusive-C14N], dengan segala hal lainnya ditolak secara fail-closed. Trust tidak pernah bootstrap dari dokumen itu sendiri: sertifikat KeyInfo hanya pernah berantai ke anchor yang Anda konfigurasikan. Freshness berada pada TslDocument itu sendiri, sehingga setiap jalur konsumen menegakkannya alih-alih satu kolaborator opsional. Hasilnya adalah kernel kecil yang dapat diuji, deterministik, dan jujur tentang apa yang ia tolak.

Latar belakang desain: Qualified signature, dijelaskan.

Permukaan API

TslPolicyEnforcer

Titik masuk yang diorkestrasi: fetch, verify, parse, dan pemeriksaan freshness dalam satu panggilan.

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

Melempar atau gagal dengan: TslFetchException dan NextPDF\Enterprise\Security\NetworkPolicyViolation dari tahap fetch; TslSignatureException dari verifikasi tanda tangan; TslParseException dari parsing, dari sebuah nilai NextUpdate yang non-kanonik, atau dari sebuah list yang usang. Kedua metode mengembalikan sebuah TslDocument hanya bila setiap gate lulus. Freshness gate di sini membandingkan NextUpdate terhadap jam sistem saat ini.

TslFetcher

HTTP fetcher dengan caching berbasis ETag dan sebuah gate network-policy.

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

Melempar atau gagal dengan: TslFetchException pada URL non-HTTPS, sebuah host yang ditolak (SSRF), sebuah status HTTP error, sebuah respons yang berukuran berlebih, atau sebuah body kosong; NetworkPolicyViolation ketika NetworkPolicy::STRICT_OFFLINE aktif dan tidak ada body ter-cache. Body ter-cache memenuhi revalidasi 304 Not Modified dan merupakan satu-satunya body yang dilayani di bawah STRICT_OFFLINE. Entri cache bertahan selama $defaultTtlSeconds.

TslSignatureVerifier

Verifier XMLDSig untuk trusted list bertanda tangan.

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

public function verify(string $xml): string

verify() mengembalikan PEM dari sertifikat penanda-tangan, terbukti berantai ke salah satu dari $trustAnchorsPem. Konstruktor melempar InvalidArgumentException ketika daftar anchor kosong. $clockTolerance melebarkan jendela validitas sertifikat secara simetris, dalam satuan detik.

Profil yang diterima bersifat tetap. Algoritma tanda tangan: allowlist ALLOWED_SIG_ALG (rsa-sha256/384/512, ecdsa-sha256/384/512). Digest: allowlist ALLOWED_DIGEST_ALG (SHA-256, SHA-384, SHA-512). Kanonikalisasi: exclusive C14N 1.0 saja. SHA-1 dan MD5 ditolak sebagai unsupported_algorithm.

Melempar atau gagal dengan: TslSignatureException, membawa sebuah reason yang machine-readable:

Kode reason	Makna
missing_signature	Dokumen tidak memiliki elemen ds:Signature.
untrusted_signer	Sertifikat KeyInfo tidak berantai ke sebuah anchor yang dikonfigurasi.
invalid_signature	Cacat struktural, atau pemeriksaan RSA/ECDSA gagal.
digest_mismatch	Digest referensi tidak cocok dengan dokumen yang telah dikanonikalisasi.
unsupported_algorithm	Algoritma tanda tangan atau digest di luar allowlist.
unsupported_transform	Pipeline kanonikalisasi atau transform di luar profil tetap.
expired_anchor	Sebuah sertifikat rantai berada di luar jendela validitasnya, atau validitasnya tidak dapat di-parse.

TslXmlParser

Parser struktural yang signature-agnostic. Pemanggil WAJIB memverifikasi sebelum mempercayai output-nya; TslPolicyEnforcer menegakkan urutan itu untuk Anda.

public function parse(string $xml): TslDocument

Melempar atau gagal dengan: TslParseException ketika XML mendeklarasikan sebuah DOCTYPE (pengerasan XXE dan entity-expansion), tidak dapat di-parse, tidak memiliki root TrustServiceStatusList, atau membawa sebuah TSLSequenceNumber yang tidak valid. Kelas ini mengekspos konstanta namespace NS_TSL, NS_DSIG, dan NS_TSL_X.

TslDocument dan TspService

TslDocument adalah sebuah value object yang immutable: schemeTerritory, schemeOperatorName, tslType, sequenceNumber, issueDateTime, nextUpdate, tspServices, dan rawXmlSha256 (evidence hash atas byte mentah).

public function isStale(DateTimeImmutable $now): bool

public function assertFresh(DateTimeImmutable $now): void

public function servicesOfType(string $serviceTypeIdentifier): array

public function activeServices(): array

Melempar atau gagal dengan: isStale() dan assertFresh() melempar TslParseException ketika nextUpdate bukan sebuah dateTime UTC kanonik dengan Z eksplisit atau numeric offset; sebuah list yang usang membuat assertFresh() melempar. activeServices() mengembalikan hanya layanan berstatus granted. servicesOfType() menyaring berdasarkan URI service-type ETSI.

Setiap entri TspService mengekspos tspName, serviceName, serviceTypeIdentifier, serviceStatus, statusStartingTime, serviceCertificatePem, qualifiers, dan additionalServiceInformation, ditambah:

public function isGranted(): bool

public function isQualifiedCa(): bool

Konstanta yang berguna: TspService::STATUS_GRANTED, TspService::STATUS_WITHDRAWN, TspService::TYPE_CA_QC, TspService::TYPE_OCSP_QC, TspService::TYPE_TSA_QTST. URI qualifier (misalnya TspServiceQualifier::FOR_ESIG, FOR_ESEAL, QSCD_STATEMENT, NO_QSCD) muncul pada TspServiceQualifier untuk lapisan pemetaan eIDAS.

TslTrustAnchorProvider dan bundel anchor

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

Melempar atau gagal dengan: TslParseException ketika TSL usang pada $now, ketika nextUpdate bukan sebuah nilai UTC kanonik, atau ketika list tidak mengandung layanan CA/QC yang aktif.

Catatan BC — aturan freshness buildBundle($now). buildBundle() membutuhkan instan validasi dan memanggil TslDocument::assertFresh($now) sebelum mengekstrak satu anchor pun. Revisi terdahulu dapat menurunkan anchor dari sebuah TslDocument hasil parser tanpa pemeriksaan freshness apa pun. Pemanggil yang memberikan list ter-cache atau terarsip kini harus meneruskan instan tempat validasi mereka berjalan; sebuah list yang usang pada instan itu akan melempar alih-alih diam-diam menyemai trust anchor.

EnterpriseCaTrustAnchorBundle yang dikembalikan adalah sebuah value object yang read-only: anchorsPem (anchor PEM), bundleVersion (tsl-<territory>-seq<N>), dan bundleSha256 (integrity digest atas konkatenasi PEM yang dikanonikalisasi). Peroleh ia dari buildBundle(); jangan mengonstruksinya secara manual — konstruktor melempar InvalidArgumentException pada ketidakcocokan digest atau PEM yang malformed.

public function containsFingerprint(string $anchorDerSha256Hex): bool

public static function computeBundleSha256(array $anchorsPem): string

Contoh kode — Mulai cepat

Autentikasi dan konsumsi sebuah trusted list yang di-mirror secara lokal. Tidak ada dependensi HTTP yang dibutuhkan untuk jalur ini: verify, parse, lalu gate freshness pada instan validasi Anda.

tsl-verify-quickstart.php

<?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 yang diharapkan (nilai bervariasi menurut list):

Territory: DE
Sequence: 127
Active services: 143

Contoh kode — Produksi

Rangkaikan pipeline online penuh: fetch yang terjaga dengan caching, verifikasi tanda tangan, parse, freshness, lalu penurunan bundel anchor. Setiap kelas kegagalan ditangkap dan dilaporkan secara berbeda.

tsl-anchor-bundle-production.php

<?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 yang diharapkan (nilai bervariasi menurut list):

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

Catat bundleVersion dan bundleSha256 pada setiap validasi yang Anda lakukan terhadap bundel. Keduanya menamai kumpulan anchor yang tepat di balik setiap verdict.

Kasus tepi & jebakan

• Freshness gate enforcer menggunakan jam saat ini. fetchAndVerify() dan verifyXml() menolak sebuah list yang NextUpdate-nya sudah terlewati. Untuk validasi historis terhadap sebuah list terarsip, jalankan TslSignatureVerifier dan TslXmlParser secara langsung, lalu panggil assertFresh() dengan instan lampau yang didukung bukti Anda.
• buildBundle() menegaskan ulang freshness pada $now Anda. Sebuah list yang lulus enforcer tetap dapat ditolak di sini bila instan validasi Anda lebih belakangan. Lihat catatan BC di atas.
• Jangan pernah menyemai trustAnchorsPem dari list yang sedang Anda verifikasi. Anchor harus berasal dari sumber pinned out-of-band (untuk LOTL) atau dari sebuah list induk yang sudah terverifikasi (untuk TSL negara anggota). Selain itu membuat verifikasi menjadi sirkular.
• Sebuah DOCTYPE di mana pun bersifat fatal. TSL yang conforming tidak pernah membawa DTD, jadi parser menolak DOCTYPE apa pun sebelum libxml membangun sebuah tabel entity. Ini adalah pengerasan yang disengaja, bukan keterbatasan parser.
• Field struktural yang hilang menurun secara aman. Sebuah layanan tanpa status yang terbaca diperlakukan sebagai withdrawn, sehingga ia tidak pernah dapat menjadi anchor. Scheme territory yang hilang mem-parse sebagai unknown. Default yang fail-closed menjaga entri yang malformed tetap keluar dari material trust.
• Intermediate harus benar-benar CA. Selama pembangunan rantai, sebuah kandidat issuer tanpa basicConstraints cA=TRUE (atau yang menegaskan keyUsage tanpa keyCertSign) dilewati. Sebuah sertifikat end-entity yang diselundupkan ke dalam KeyInfo tidak dapat berperan sebagai intermediate jalur. Rantai dibatasi pada kedalaman 8.
• NextUpdate harus UTC kanonik. Sebuah nilai tanpa Z eksplisit atau numeric offset melempar TslParseException. Ia tidak pernah ditafsirkan ulang dalam timezone lokal server.
• List besar dan batas byte. Respons dibaca hingga $maxBytes (default 16 MiB). Naikkan batasnya pada konstruktor jika list skema Anda lebih besar; truncation muncul sebagai kegagalan tanda tangan, tidak pernah sebagai penerimaan diam-diam.
• clockTolerance hanya melebarkan. Ia menambahkan slack simetris pada pemeriksaan validitas sertifikat. Ia tidak melonggarkan freshness gate tingkat-list.

Catatan keamanan

• Verifikasi sebelum parse, selalu. TslXmlParser bersifat signature-agnostic secara desain. TslPolicyEnforcer mengurutkan verifikasi terlebih dahulu; jika Anda menyusun potongan-potongannya sendiri, pertahankan urutan itu.
• Pertahanan SSRF berlapis. fetch() mensyaratkan https:// dan memvalidasi host terhadap rentang private, loopback, link-local, CGN, dan cloud-metadata, dengan resolusi DNS A dan AAAA untuk memitigasi rebinding. Sebuah URL yang ditolak melempar sebelum egress apa pun.
• Pengerasan XXE dan entity-expansion. Dokumen yang mengandung DOCTYPE ditolak sebelum tabel entity ada dan sekali lagi setelah load. Pemuatan network entity dinonaktifkan; external entity tidak pernah disubstitusi.
• Profil XMLDSig ketat. Exclusive C14N saja; tepat pasangan transform [enveloped-signature, exclusive-C14N]; referensi yang terverifikasi harus mencakup root dokumen; transform enveloped hanya menghapus tanda tangan yang terverifikasi, mempertahankan tanda tangan sibling. Algoritma yang deprecated (SHA-1, MD5) ditolak.
• Disiplin rantai. Setiap tautan rantai — penanda-tangan, intermediate, dan kasus direct-anchor — diperiksa validitas temporalnya, fail-closed pada batas validitas yang tidak dapat di-parse. Loop dideteksi; kedalaman dibatasi.
• Postur air-gap. Di bawah NetworkPolicy::STRICT_OFFLINE, jalur fetch tidak melakukan egress keluar sama sekali; hanya body yang sebelumnya ter-cache yang boleh dilayani, dan segala hal lainnya melempar NetworkPolicyViolation secara fail-fast.
• Digest bundel mendeteksi korupsi, bukan tampering. bundleSha256 divalidasi saat konstruksi dan mendeteksi transcription drift. Ketika digest diturunkan dari anchor yang sama yang ia lindungi, ia bukan bukti tamper yang independen. Pin digest secara out-of-band saat mengangkut bundel antar sistem.

Konformansi

Pipeline mengonsumsi trusted list sebagaimana didefinisikan ETSI TS 119 612: ia mengautentikasi tanda tangan operator skema (§5.7), mem-parse scheme information dan struktur daftar provider (§5.3, §5.4, §5.5), menegakkan aturan dateTime UTC (§5.1.3), dan membuang list yang NextUpdate-nya sudah terlewati (§5.3.15). Ini mendukung model eIDAS Article 22 tentang trusted list yang bertanda tangan dan machine-processable. Pembangunan rantai menerapkan gate basic-constraints dan key-usage RFC 5280 pada kandidat issuer.

Dukungan bukanlah konformansi, dan konformansi bukanlah sertifikasi. NextPDF mengimplementasikan pemeriksaan yang dijelaskan halaman ini; ia belum disertifikasi terhadap ETSI TS 119 612, eIDAS, atau standar lain oleh badan mana pun, dan NextPDF tidak memegang sertifikasi serta tidak memberikannya. Mengonsumsi sebuah trusted list melalui API ini dengan sendirinya tidak membuat sebuah tanda tangan menjadi “qualified” atau berkekuatan hukum. Apakah proses validasi lengkap Anda memenuhi sebuah persyaratan hukum atau pengadaan adalah penentuan bagi asesor Anda.

Perilaku mode-FIPS

Verifikasi tanda tangan TSL menjalankan pemeriksaan RSA dan ECDSA in-process melalui pustaka crypto yang di-bundel. Ia tidak dirutekan melalui runtime guard mode-FIPS Enterprise, dan mengaktifkan mode FIPS tidak mengubah perilakunya. Ia bukan layanan kriptografis FIPS-validated, dan tidak ada sertifikasi FIPS 140 yang diklaim. Deployment dengan kewajiban FIPS harus melingkupi API ini sesuai kebutuhan dan melihat Kebijakan kriptografis FIPS 140-2/3.

Kontrak perilaku

• fetch() melakukan egress hanya untuk URL HTTPS yang lulus validasi SSRF, membaca paling banyak $maxBytes, dan menghormati NetworkPolicy yang dikonfigurasi; di bawah STRICT_OFFLINE hanya sebuah body ter-cache yang pernah dikembalikan.
• Tidak ada output parser yang menjadi material trust sebelum verify() berhasil; TslPolicyEnforcer menjamin urutan tersebut.
• verify() mengembalikan PEM penanda-tangan hanya ketika pemeriksaan digest dan tanda tangan lolos di bawah profil tetap dan penanda-tangan berantai, dalam kedalaman 8 dan dengan setiap tautan valid secara temporal, ke sebuah anchor yang dikonfigurasi.
• Enforcer menolak list mana pun yang NextUpdate-nya sudah terlewati pada jam saat ini; buildBundle() menegaskan ulang freshness pada instan yang disuplai pemanggil sebelum menurunkan anchor.
• Anchor diturunkan secara eksklusif dari layanan berstatus granted dengan service type CA/QC; sebuah kumpulan aktif yang kosong melempar alih-alih menghasilkan bundel kosong.
• Setiap kegagalan adalah exception bertipe (TslFetchException, NetworkPolicyViolation, TslSignatureException dengan sebuah kode reason, TslParseException); tidak ada metode yang mengembalikan dokumen yang parsial atau tidak terverifikasi.

Fallback Core

NextPDF Core memvalidasi tanda tangan PDF terhadap trust anchor yang Anda pin secara eksplisit melalui kontrak CaTrustAnchorBundle-nya — lihat Keamanan Core. Core tidak memiliki kapabilitas trusted-list: tidak ada pengambilan TSL, tidak ada autentikasi list XMLDSig, tidak ada parsing ETSI TS 119 612, dan tidak ada penurunan anchor dari entri qualified-service. Dengan Core saja Anda memelihara kumpulan anchor Anda secara manual; menurunkannya dari trusted list UE yang terautentikasi membutuhkan NextPDF Enterprise.

Batas publikasi

Halaman ini mendokumentasikan hanya perilaku yang dapat diamati secara eksternal dan permukaan public API yang didukung. Jalur namespace internal, kelas helper, tabel mekanisme, nama file runbook, dan prefiks tiket berada di luar cakupan.

Lihat juga

• Pengikatan trust ASiC — mengikat penanda-tangan kontainer ke bundel anchor yang diturunkan halaman ini.
• Level asuransi eIDAS — memetakan bukti TspService ke Level of Assurance.
• Verifikasi tanda tangan — sisi verify yang mengonsumsi trust anchor untuk validasi jalur.
• Keamanan — referensi mendalam — referensi tingkat-kontrak modul keamanan Enterprise.
• Qualified signature, dijelaskan — mengapa trusted list menjangkarkan model trust UE.
• Validasi jangka panjang — mengapa waktu validasi dan bukti yang terjaga penting.