Enterprise Edition

Sicherheit — Ausführliche Referenz (HSM, PKCS#11, FIPS-Modus)

Auf einen Blick

Diese Seite ist die kombinierte ausführliche Referenz für die Sicherheitsoberfläche von NextPDF Enterprise. Sie behandelt die Hardware-Token-Signierung über PKCS#11, die Subprozess-Signierung über die OpenSSL-Kommandozeilenschnittstelle (CLI), die FIPS-Krypto-Richtlinienvoreinstellungen, den Laufzeit-FIPS-Wächter und den Power-on-Selbsttest-Wächter. Es gibt zwei fokussierte Begleitdokumente: HSM — Ausführliche Referenz für die Signierer-Details und FIPS 140 — Ausführliche Referenz für die Details zum FIPS-Modul. Der Post-Quantum-Signierpfad ist eine Vorschau ohne Konformitätsanspruch. NextPDF besitzt keine Zertifizierung und erteilt keine; Unterstützung bedeutet nicht Konformität, und Konformität bedeutet nicht Zertifizierung.

Verfügbarkeit & Lizenzierung

Diese Funktion wird mit NextPDF Enterprise (nextpdf/enterprise) ausgeliefert und aktiviert sich mit einer Lizenzhülle der Enterprise-Stufe. Eine Bereitstellung ohne diese Berechtigung lädt die Klassen der Funktion nicht. Editionen vergleichen und eine Lizenz erwerben.

Öffentliche API-Oberfläche

composer require nextpdf/enterprise:^3

Die Signiertypen liegen in NextPDF\Enterprise\Security\Signature\Hsm; die FIPS-Typen liegen in NextPDF\Enterprise\Security\Fips; die Kompositionswurzel liegt in NextPDF\Enterprise\Bootstrap. Beide Signierer implementieren den Core-Vertrag NextPDF\Contracts\HsmSignerInterface. Die Richtlinie implementiert die Core-Verträge NextPDF\Contracts\CryptoPolicyInterface und NextPDF\Contracts\PreOperationalSelfTestInterface.

Symbol	Parameter	Standardverhalten	Rückgabe	Wirft oder scheitert mit	Hinweise
`Pkcs11Signer::__construct()`	`string $libraryPath`, `int $slotId`, `string $pin`, `string $certLabel`, `?string $keyLabel = null`, `array $chainDer = []`, `bool $enablePostQuantum = false`, `?FipsSignatureEnforcer $fipsEnforcer = null`	Öffnet die Anbieterbibliothek, meldet sich am Slot an, lädt Zertifikat- und Schlüsselalgorithmus-Metadaten	—	`HsmOperationException`, wenn `ext-pkcs11` fehlt oder der Token-Zugriff scheitert	PIN und Labels sind `#[SensitiveParameter]`; pro Bibliothekspfad wird pro Prozess ein Modul-Handle zwischengespeichert
`Pkcs11Signer::isAvailable()`	Keine	Meldet, ob `ext-pkcs11` geladen ist	`bool`	Keine	Statisch; vor der Konstruktion prüfen
`Pkcs11Signer::sign()`	`string $data`, `string $algorithm = 'sha256WithRSAEncryption'`	Signiert auf dem Token; rohe ECDSA-Ausgabe wird in DER `ECDSA-Sig-Value` konvertiert	`string` rohe Signatur-Bytes	`HsmOperationException` (Schlüssel nicht gefunden, Token-Fehler); `InvalidArgumentException` (nicht zugeordneter Algorithmus); `FipsViolationException` / `FipsModuleErrorStateException` vor dem Signieren, wenn ein Enforcer verdrahtet ist	Geschlossene Algorithmenmenge; siehe Verhaltensvertrag
`Pkcs11Signer::signPqs()`	`string $data`, `Pkcs11PqsAlgorithm $algorithm`, `string $context = ''`, `bool $randomized = true`	Verweigert, sofern `$enablePostQuantum` nicht gesetzt war; verteilt den provisorischen PKCS#11-Post-Quantum-Mechanismus	`string` rohe Signatur-Bytes	`HsmOperationException` (deaktiviert, Token-Fehler, Signaturlängen-Abweichung); `InvalidArgumentException` (Kontext über 255 Bytes)	Vorschau; kein Konformitätsanspruch
`Pkcs11Signer` Zugriffsoberfläche	Keine	Schreibgeschützte Konstruktionsergebnisse	`bool` / `string` / `array<string>`	Keine	`isPostQuantumEnabled`, `getCertificateDer`, `getCertificateChainDer`, `getPublicKeyAlgorithm`
`OpenSslCliSigner::__construct()`	`string $keyUri`, `string $certPath`, `string $pin`, `array $extraCertPaths = []`, `OpenSslCliBackend $backend = OpenSslCliBackend::Auto`, `string $opensslBinary = 'openssl'`, `int $timeoutSeconds = 30`, `?string $modulePath = null`, `?string $configPath = null`, `bool $legacyPinDelivery = false`, `?FipsSignatureEnforcer $fipsEnforcer = null`	Verifiziert `proc_open`, prüft das Binary, löst das Backend auf, lädt die Zertifikate	—	`HsmOperationException` (`proc_open` deaktiviert, fehlende Modul-/Konfig-/Zertifikatsdatei, kein Backend); `InvalidArgumentException` (`pin-value` innerhalb von `$keyUri`)	`Auto` bevorzugt den OpenSSL-3.x-Provider, danach die Engine
`OpenSslCliSigner::sign()`	`string $data`, `string $algorithm = 'sha256WithRSAEncryption'`	Signiert in einem `openssl`-Subprozess; die PIN wird standardmäßig über eine ephemere `0600`-pin-source-Datei übertragen	`string` rohe Signatur-Bytes	`HsmOperationException` (Timeout, PIN abgelehnt, Schlüssel nicht gefunden, leere Ausgabe); `InvalidArgumentException` (nicht zugeordneter Algorithmus); FIPS-Gate-Ausnahmen vor dem Signieren	Der Subprozess wird nach `$timeoutSeconds` beendet; stderr wird redigiert
`OpenSslCliSigner` Zugriffsoberfläche	Keine	Schreibgeschützte Konstruktionsergebnisse	`string` / `array<string>` / `OpenSslCliBackend`	Keine	`getCertificateDer`, `getCertificateChainDer`, `getPublicKeyAlgorithm`, `getCertificatePem`, `getResolvedBackend`, `getOpensslVersion`
`OpenSslCliBackend`	—	Enum: `Provider`, `Engine`, `Auto`	—	Keine	Backend-Auswahl für den CLI-Signierer
`Pkcs11PqsAlgorithm`	—	Enum der ML-DSA- und SLH-DSA-Parametersätze	—	Keine	Hilfsfunktionen: `isMlDsa`, `isSlhDsa`, `mechanismId`, `parameterSetId`, `signatureLength`, `nistCategory`
`PqsCapabilityStatus::current()`	Keine	Erstellt die ehrliche Post-Quantum-Haltung für den Prozess	`PqsCapabilityStatus`	Keine	Jeder Konformitätsanspruch-Boolean ist fest auf `false` codiert; kein Flag kann einen einschalten
`HsmSignerProviderAdapter`	`HsmSignerInterface $hsm`, `string $providerId`, `SignatureAlgorithm $algorithm = SignatureAlgorithm::Pkcs1v15`	Stellt ein HSM-Konkret als einheitliches `SignerProviderInterface` bereit	Gemäß SPI	`KeyManagementException` (nicht-null Schlüsselversion); `SignatureFailedException` (Treiberfehler, leere Signatur)	Provider-IDs: `pkcs11-{module-id}`, `openssl-cli`
`HsmOperationException`	—	Typisierter Fehler für jeden HSM-Signierpfad	—	—	Erweitert das Core-`NextPdfException`
`FipsCryptoPolicy::strict()` / `::standard()`	`?FipsSelfTest $selfTest = null`	Factory-Voreinstellungen; strict ist das FIPS-140-3-Profil, standard fügt AES-128-CBC hinzu	`FipsCryptoPolicy`	Keine	Unveränderliche Zulassungslisten; siehe FIPS-Modus-Verhalten
`FipsCryptoPolicy` Prädikatoberfläche	`string` / `int` Eingaben	Zulassungslisten-Mitgliedschaftsprüfungen	`bool` / `string`	Keine	`isHashAlgorithmAllowed`, `isSignatureAlgorithmAllowed`, `isEncryptionAlgorithmAllowed`, `isKeyStrengthAllowed`, `getPreferredHashAlgorithm`, `getName`
`FipsCryptoPolicy::assertPreOperational()`	Keine	Führt den Power-on-Selbsttest aus (oder wiederholt ihn)	`void`	`FipsModuleErrorStateException`	Angetrieben durch die Core-Durchsetzungsnaht bei der ersten kryptografischen Operation
`FipsModeGuard::__construct()`	`CryptoPolicyInterface $policy`, `?FipsBootGuard $bootGuard = null`, `?FipsAuditLogger $auditLogger = null`	Umhüllt eine Richtlinie mit assert-artigen Grenzen	—	Keine	Ohne Boot-Guard fehlt das Selbsttest-Gate (nur Richtlinie)
`FipsModeGuard` Assert-Oberfläche	`string` / `int` Eingaben	Zuerst Verweigerungskatalog, dann Zulassungsliste; Audit-Datensatz vor jedem Wurf	`void`	`FipsViolationException`; `FipsModuleErrorStateException` (Boot-Guard verdrahtet)	`assertHashAllowed`, `assertSignatureAlgorithmAllowed`, `assertEncryptionAllowed`, `assertKeyStrengthAllowed`, plus `getPolicy`
`FipsBootGuard::report()` / `::rerun()`	Keine	Führt die Selbsttest-Batterie aus (zwischengespeichert / erzwungen)	`FipsSelfTestReport`	Keine	Ein ERROR-Bericht verriegelt den Prozess; ein bestandener Wiederholungslauf hebt die Verriegelung niemals auf
`FipsBootGuard::assertOperational()`	Keine	Stellt sicher, dass das Modul OPERATIONAL ist	`void`	`FipsModuleErrorStateException`	Klebrig: ein prozessverriegelter ERROR-Zustand weist selbst eine saubere Instanz ab
`FipsBootGuard::status()`	Keine	Meldet den zwischengespeicherten Status	`FipsSelfTestStatus`	Keine	`PRE_OPERATIONAL`, `OPERATIONAL` oder `ERROR`
`FipsSelfTest::run()`	Keine	Führt die vollständige Known-Answer-Test-Batterie aus; bricht niemals vorzeitig ab	`FipsSelfTestReport`	Keine	Der Konstruktor akzeptiert injizierbare Hash- und Random-Bytes-Provider für deterministische Tests
`FipsSelfTestReport` / `FipsSelfTestResult` / `FipsSelfTestStatus`	—	Bericht-Value-Objekte und Status-Enum	—	`FipsSelfTestReport::assertOperational()` wirft `FipsModuleErrorStateException`	`results` listet stets jedes Ergebnis als Audit-Beweis auf
`FipsSignatureEnforcer::assertSignatureGenerationAllowed()`	`string $algorithm`, `string $certificatePem`	Löst die Signatur-OID und die Schlüsselstärke auf, delegiert dann an den Wächter	`void`	`FipsViolationException` (unzulässig oder nicht klassifizierbar, fail-closed)	Der Engpass, den beide Signierer im FIPS-Modus am Anfang von `sign()` aufrufen
`FipsAuditLogger`	`CryptoPolicyInterface $policy`, `LoggerInterface $logger`	Gibt ALLOW- (INFO) / DENY- (WARNING) Datensätze pro Entscheidung aus	`bool` pro Log-Aufruf	Keine	`logHashOperation`, `logSignatureOperation`, `logEncryptionOperation`, `logKeyStrengthCheck`
`FipsTransitioningAlgorithms`	`string` / `int` Eingaben	Statischer NIST-SP-800-131A-Verweigerungskatalog	`bool` / `array`	Keine	Die Explizit-Verweigerungsschicht unter jeder Wächtergrenze
`FipsBootstrap::boot()` / `::lazy()`	`?CryptoPolicyInterface $policy = null`, `?FipsSelfTest $selfTest = null`, `?LoggerInterface $auditLogger = null`	Komponiert Boot-Guard, Richtlinie und Modus-Wächter; `boot()` führt den Selbsttest sofort aus, `lazy()` verschiebt ihn auf die erste Grenze	`FipsModeGuard`	`boot()`: `FipsModuleErrorStateException` bei einem fehlgeschlagenen Test	Standardmäßig die strict-Richtlinie
`FipsBootstrap::signatureEnforcer()`	`?CryptoPolicyInterface $policy = null`, `?FipsSelfTest $selfTest = null`	Bootet das Modul und gibt das Erzeugungszeit-Gate für die Signierer zurück	`FipsSignatureEnforcer`	`FipsModuleErrorStateException`	Übergeben Sie das Ergebnis an den Parameter `$fipsEnforcer` eines Signierers
`FipsBootstrap::selfTestReport()`	`?FipsSelfTest $selfTest = null`	Führt die Batterie bei Bedarf aus und fasst sie zusammen	`array{status, operational, failed}`	Keine	Vorgesehen für Health-Endpunkte und den CLI-Unterbefehl
`FipsViolationException` / `FipsModuleErrorStateException`	—	Typisierte FIPS-Fehler	—	—	Legen `policyName` / `violatingItem` / `reason` bzw. `failedResults` offen

public function __construct(private readonly string $libraryPath, private readonly int $slotId, #[SensitiveParameter] private readonly string $pin, #[SensitiveParameter] private readonly string $certLabel, #[SensitiveParameter] private readonly ?string $keyLabel = null, array $chainDer = [], private readonly bool $enablePostQuantum = false, ?FipsSignatureEnforcer $fipsEnforcer = null)
public static function isAvailable(): bool
public function sign(string $data, string $algorithm = 'sha256WithRSAEncryption'): string
public function signPqs(string $data, Pkcs11PqsAlgorithm $algorithm, string $context = '', bool $randomized = true): string

public function __construct(private string $keyUri, string $certPath, #[SensitiveParameter] private string $pin, array $extraCertPaths = [], private OpenSslCliBackend $backend = OpenSslCliBackend::Auto, private string $opensslBinary = 'openssl', private int $timeoutSeconds = 30, private ?string $modulePath = null, private ?string $configPath = null, private bool $legacyPinDelivery = false, private ?FipsSignatureEnforcer $fipsEnforcer = null)
public function sign(string $data, string $algorithm = 'sha256WithRSAEncryption'): string

public static function strict(?FipsSelfTest $selfTest = null): self
public static function standard(?FipsSelfTest $selfTest = null): self
public function assertPreOperational(): void

public function __construct(private CryptoPolicyInterface $policy, private ?FipsBootGuard $bootGuard = null, private ?FipsAuditLogger $auditLogger = null)
public function assertHashAllowed(string $algorithm): void
public function assertSignatureAlgorithmAllowed(string $oid): void
public function assertEncryptionAllowed(string $algorithm): void
public function assertKeyStrengthAllowed(string $keyType, int $bitLength): void
public function getPolicy(): CryptoPolicyInterface

public static function boot(?CryptoPolicyInterface $policy = null, ?FipsSelfTest $selfTest = null, ?LoggerInterface $auditLogger = null): FipsModeGuard
public static function lazy(?CryptoPolicyInterface $policy = null, ?FipsSelfTest $selfTest = null, ?LoggerInterface $auditLogger = null): FipsModeGuard
public static function signatureEnforcer(?CryptoPolicyInterface $policy = null, ?FipsSelfTest $selfTest = null): FipsSignatureEnforcer
public static function selfTestReport(?FipsSelfTest $selfTest = null): array

Verhaltensvertrag

Vertragsauflösung. Beide Signierer implementieren das Core-HsmSignerInterface; die Richtlinie implementiert das Core-CryptoPolicyInterface. Aufrufender Code hängt von den Verträgen ab, sodass ein Editions-Upgrade die Komposition ändert, nicht die Aufrufstellen.
Schlüsselverwahrung. Der private Schlüssel verlässt niemals die Token-Grenze. Pkcs11Signer delegiert die Operation an das Token; OpenSslCliSigner übergibt dem Subprozess eine PKCS#11-URI-Schlüsselreferenz. NextPDF speichert, erzeugt oder garantiert die Sicherheit des Signierschlüssels nicht. Der Schlüsselschutz liegt in der Verwahrungsverantwortung des Betreibers (NIST SP 800-57 Part 1 Rev.5 §5.5.2).
Sitzung und Anmeldung. Die Token-Signieroperation, die Sitzung und die Benutzeranmeldung folgen PKCS#11 v3.1 §5. Das Zertifikatslabel und das Privatschlüssellabel dürfen sich unterscheiden; der Konstruktor akzeptiert für solche Token ein separates Schlüssellabel.
Geschlossene Algorithmenmenge. Die Signierer akzeptieren genau: RSA PKCS#1 v1.5 mit SHA-256/384/512, RSASSA-PSS mit SHA-256/384/512 und ECDSA mit SHA-256/384/512 (Pkcs11Signer akzeptiert zusätzlich ecdsa-raw). Jeder andere Bezeichner löst InvalidArgumentException aus; es wird niemals ein Ersatzalgorithmus signiert.
PSS-Salt-Bindung. Für jede PSS-Variante entspricht die Salt-Länge der Digest-Länge — 32, 48 oder 64 Bytes — und die Hash- und Mask-Generation-Parameter entsprechen dem gewählten Digest (PKCS#11 v3.1 §5).
ECDSA-Konvertierung. Token-ECDSA-Mechanismen geben eine rohe Signatur zurück; sign() konvertiert sie in die DER-codierte ECDSA-Sig-Value-Form zur Interoperabilität mit PDF und OpenSSL. Die Signaturerzeugung folgt FIPS 186-5 §6.3.2.
Voreinstellungsinhalt. Die strict-Voreinstellung erlaubt SHA-256/384/512; RSA- und ECDSA-Signatur-OIDs mit diesen Hashes; RSASSA-PSS; AES-256-CBC und AES-256-GCM; mindestens RSA 2048 und EC 256. Die standard-Voreinstellung erlaubt zusätzlich AES-128-CBC für Alt-Interoperabilität. Jede AES-GCM-Nutzung erfordert einen eindeutigen Initialisierungsvektor pro Schlüssel (NIST SP 800-38D §5).
Zweischichtige Durchsetzung. Jede Wächtergrenze konsultiert zuerst den expliziten NIST-SP-800-131A-Verweigerungskatalog, dann die Richtlinien-Zulassungsliste. Die Verweigerungsschicht erzeugt das audit-eindeutige „disallowed”-Signal; die Zulassungsliste bleibt maßgeblich.
Power-on-Selbsttest. Die Batterie umfasst SHA-256/384/512, HMAC-SHA-256, AES-256-CBC, AES-256-GCM, einen ECDSA-P-256-Pairwise-Consistency-Test und eine Random-Bit-Health-Prüfung. Die erste kryptografische Operation unter der Richtlinie auf dem Core-Pfad führt ihn einmal pro Prozess aus, fail-closed. Ein Fehlschlag versetzt das Modul in den ERROR-Zustand; kryptografische Dienste werden bis zum Reset verweigert. Dies folgt ISO/IEC 19790:2025 §7.10, §7.10.2, §7.10.3 und §7.10.3.p3.
Klebriger ERROR-Zustand. Ein beobachteter ERROR verriegelt für den gesamten Prozess. Die Konstruktion einer frischen Richtlinie oder eines frischen Boot-Guards kann ihn nicht reinwaschen; ein bestandener Wiederholungslauf hebt ihn nicht auf. Nur ein Prozessneustart — ein echter Power-Cycle — setzt den Zustand zurück.
Nur Erzeugungs-Gate. FipsSignatureEnforcer regelt die Erzeugung neuer Signaturen. Die Validierung bereits vorhandener Signaturen ist Legacy-Nutzung und wird niemals über den Enforcer geleitet.
Audit-Spur. Wenn ein Wächter mit einem Audit-Logger komponiert wird, gibt jede Grenze einen ALLOW- oder DENY-Datensatz aus, bevor die Operation erlaubt oder abgelehnt wird. Der Logger konsultiert dieselbe Richtlinie, die der Wächter durchsetzt, sodass die aufgezeichnete Entscheidung nicht abweichen kann.

Grenzfälle & Fehlermodi

Die Konstruktion von Pkcs11Signer ohne ext-pkcs11 löst sofort HsmOperationException aus; die Erweiterung ist nicht in Standard-PHP-Distributionen enthalten.
Ein Zertifikats- oder Privatschlüssellabel, das keinem Token-Objekt entspricht, löst HsmOperationException aus und benennt die fehlende Objektklasse.
OpenSslCliSigner verweigert bei der Konstruktion eine $keyUri, die pin-value enthält, fail-closed; die PIN wird stattdessen über den sicheren pin-source-Pfad übertragen.
Im FIPS-Modus wird ein Algorithmusbezeichner, der keiner bekannten Signatur-OID zugeordnet werden kann, fail-closed verweigert; ebenso ein Zertifikat, dessen Public-Key-Stärke nicht bestimmt werden kann.
Ein unbekannter Schlüsseltyp wird standardmäßig verweigert; die Richtlinie fällt niemals auf einen schwächeren Algorithmus zurück.
Ein fehlgeschlagener Known-Answer-Test löst FipsModuleErrorStateException mit den fehlgeschlagenen Ergebnissen aus; jede spätere Grenze im Prozess wiederholt den Fehler bis zum Neustart.
Ein ohne Boot-Guard konstruierter Wächter setzt die Zulassungslisten durch, bietet aber kein Selbsttest-Gate; die Produktions-FIPS-Komposition liefert eines über den Bootstrap.
signPqs() verweigert die Ausführung, sofern der Konstruktor-Opt-in nicht gesetzt war. Ein Kontextstring über 255 Bytes löst InvalidArgumentException aus (FIPS 204 §5.4). Eine zurückgegebene Signatur, deren Byte-Länge nicht dem gewählten Parametersatz entspricht, wird abgelehnt, bevor sie die Codierung erreicht.

FIPS-Modus-Verhalten

Im strict-Modus FIPS-erlaubt: SHA-256/384/512; RSA PKCS#1 v1.5 und RSA-PSS mit diesen Hashes; ECDSA mit diesen Hashes; AES-256-CBC und AES-256-GCM; RSA mindestens 2048 Bit, EC mindestens 256 Bit. Im strict-Modus FIPS-abgelehnt: schwächere oder Legacy-Hashes, nicht zugelassene Signatur-OIDs, AES-128 (nur in der standard-Voreinstellung erlaubt) und jeder Schlüssel unterhalb der Mindeststärke. Die minimale RSA-Schlüssellänge und der Übergangsstatus folgen NIST SP 800-131A Rev.2 §3. Die ECDSA-Kurven- und Hash-Paarung folgt FIPS 186-5 §6.1.1. Der Pfad ist fail-closed und ersetzt niemals einen schwächeren Algorithmus.

NextPDF Enterprise ist kein FIPS-validiertes kryptografisches Modul und erhebt keinen FIPS-Zertifizierungsanspruch. NextPDF Enterprise arbeitet nur dann in einem FIPS-kompatiblen Modus, wenn es mit einem FIPS-validierten kryptografischen Provider — zum Beispiel einem FIPS-validierten OpenSSL-Provider — oder einem FIPS-validierten HSM konfiguriert ist. Die FIPS-Modus-Richtlinie unterstützt die Compliance; sie ist keine Zertifizierung. In diesem Repository existiert kein FIPS-Zertifizierungsartefakt.

Konformität

Anspruch	Standard	Klausel
Semantik von Token-Signieroperation, Sitzung und Benutzeranmeldung	PKCS#11 v3.1	§5 (sign)
PSS-Salt-Länge entspricht der Digest-Länge	PKCS#11 v3.1	§5 (PSS sLen)
ECDSA-Signaturerzeugung; Kurven- und Hash-Paarung	FIPS 186-5	§6.3.2; §6.1.1
Minimale RSA-Schlüssellänge und Übergangsstatus der Signaturerzeugung	NIST SP 800-131A Rev.2	§3
Selbsttest-Kategorie, Dokumentation, bedingter Auslöser, disjunkte Menge	ISO/IEC 19790:2025	§7.10, §7.10.2, §7.10.3, §7.10.3.p3
Eindeutigkeit des AES-GCM-Initialisierungsvektors	NIST SP 800-38D	§5
Schlüsselschutz und Verwahrungsverantwortung	NIST SP 800-57 Part 1 Rev.5	§5.5.2
Post-Quantum-Signierkontextstring auf 255 Bytes begrenzt	FIPS 204	§5.4

Alle Klauseln sind paraphrasiert; kein normativer Text wird wiedergegeben. Dies sind Fähigkeitsansprüche über NextPDF-Code, keine Zertifizierungen. Ob eine erzeugte Signatur verifiziert, ist die Entscheidung des Verifizierers gegen seine eigene Vertrauenskonfiguration. Die FIPS-Modus-Richtlinie ist eine Compliance-Unterstützungsfunktion, keine Rechtsmeinung; konsultieren Sie Ihre eigenen Compliance- und Rechtsberater. Dieses Modul betrifft kryptografische Funktionalität; behandeln Sie es in Ihrer eigenen Prüfung als sicherheitssensibel.

Entwicklungshinweise

Komponieren Sie den FIPS-Modus über den Bootstrap: boot() für ein Start-up-Gate, lazy(), um die Batterie auf die erste Grenze zu verschieben, und die Enforcer-Factory für den Parameter $fipsEnforcer der Signierer. Nicht-FIPS-Bereitstellungen übergeben null, und das Verhalten bleibt unverändert.
Der bin/nextpdf-enterprise-Unterbefehl fips:self-test führt die Batterie bei Bedarf aus und beendet sich im ERROR-Zustand mit einem Nicht-null-Code; verdrahten Sie ihn mit Wartungsjobs oder Admin-only-Health-Endpunkten (ISO/IEC 19790:2025 On-Demand-Selbsttests).
FipsBootGuard::resetProcessErrorLatchForTesting() ist @internal und nur für Tests; Produktionscode ruft es niemals auf, da es den klebrigen ERROR-Zustand aushebeln würde.
Konstruieren Sie Signierer einmal und verwenden Sie sie wieder; die Konstruktion meldet sich an und liest das Zertifikat, und der Modul-Cache pro Bibliothek macht wiederholte Konstruktion gegen dieselbe Bibliothek sicher.
Liefern Sie die PIN aus einem Secret-Manager. Sie ist ein #[SensitiveParameter], wird niemals protokolliert oder serialisiert; committen Sie sie nicht in die Konfiguration.
Der Betreiber ist verantwortlich für Token-Provisionierung, PIN-Handhabung, Slot-Konfiguration, Netzwerkschutz eines netzwerkangebundenen HSM und Vertrauenskonfiguration. Diese Seite legt keine Token-PIN-Richtlinien-Interna oder Anbieter-Credential-Material offen.
Aktivieren Sie die Post-Quantum-Vorschau nicht für Produktions-AdES-Signaturen. Der AdES-Krypto-Suites-Katalog erkennt Post-Quantum-Suites noch nicht an, die meisten PDF-Viewer lehnen solche Signaturen ab, und die Hardware-Round-Trip-Validierung ist nicht abgeschlossen. Interne Mechanismusdetails verbleiben in der internen Dokumentation des Quell-Repositorys und liegen außerhalb des Umfangs dieses Handbuchs.

Publikationsgrenze

Diese Seite dokumentiert ausschließlich extern beobachtbares Verhalten und die unterstützte öffentliche API-Oberfläche. Interne Namespace-Pfade, Hilfsklassen, Mechanismustabellen, Runbook-Dateinamen und Ticket-Präfixe liegen außerhalb des Umfangs.

Siehe auch

Sicherheit — NextPDF Enterprise — die Fähigkeitsseite für diese Oberfläche.
Hardware-Security-Modul-Signierung (PKCS#11) — Einrichtungs-, Konfigurations- und Verifizierungsschritte.
FIPS-140-Krypto-Richtlinie — die FIPS-Fähigkeitsseite.
HSM — Ausführliche Referenz — die fokussierte Signierer-Referenz.
FIPS 140 — Ausführliche Referenz — die fokussierte FIPS-Modul-Referenz.
Sicherheit — NextPDF Pro — die Sicherheitsoberfläche der Pro-Stufe.
Sicherheit — NextPDF Core — die Core-Sicherheitsbasislinie.