Enterprise editie

FIPS 140 — Diepe referentie

In één oogopslag

Deze pagina is de uitgebreide referentie voor de NextPDF Enterprise FIPS 140-module. De module is een policy- en zelftestcapaciteit. Ze beperkt cryptografische keuzes tot een FIPS-afgestemde allow-list, draait een power-on known-answer-test batterij, en verhindert cryptografische output wanneer de batterij faalt. NextPDF is geen FIPS 140-gevalideerde cryptografische module, heeft geen certificering en verleent er geen. Ondersteuning staat niet gelijk aan conformiteit, en conformiteit staat niet gelijk aan certificering. Een FIPS-compatibele deployment vereist bovendien een FIPS-gevalideerde cryptografische provider die door de operator wordt aangeleverd.

Beschikbaarheid en licentie

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

Publiek API-oppervlak

Alle symbolen leven in NextPDF\Enterprise\Security\Fips, behalve FipsBootstrap in NextPDF\Enterprise\Bootstrap.

Symbool	Parameters	Standaardgedrag	Retourneert	Gooit of faalt met	Opmerkingen
`FipsBootstrap::boot()`	`?CryptoPolicyInterface $policy`, `?FipsSelfTest $selfTest`, `?LoggerInterface $auditLogger` (alle standaard `null`)	Draait de power-on batterij eenmaal bij het opstarten; valt terug op de strikte policy	`FipsModeGuard`	`FipsModuleErrorStateException` bij elke gefaalde power-on test	Compositie-root; audittrail uit wanneer `$auditLogger` `null` is
`FipsBootstrap::lazy()`	Zelfde als `boot()`	Stelt de batterij uit tot de eerste grens-assertie	`FipsModeGuard`	Geen op het moment van aanroep; de eerste assertie kan `FipsModuleErrorStateException` gooien	Module blijft `PRE_OPERATIONAL` tot de eerste assertie
`FipsBootstrap::signatureEnforcer()`	`?CryptoPolicyInterface $policy = null`, `?FipsSelfTest $selfTest = null`	Boot de module en wikkelt dan de bewaking voor signer-knelpunten	`FipsSignatureEnforcer`	`FipsModuleErrorStateException` bij elke gefaalde power-on test	Delegeert naar `boot()`
`FipsBootstrap::selfTestReport()`	`?FipsSelfTest $selfTest = null`	Draait de batterij op aanvraag en vat ze samen	`array{status: FipsSelfTestStatus, operational: bool, failed: list<string>}`	Gooit niet; fouten verschijnen in `failed`	Voor admin health-endpoints en CLI-gebruik
`FipsCryptoPolicy::strict()`	`?FipsSelfTest $selfTest = null`	FIPS 140-3 preset: SHA-256/384/512; goedgekeurde RSA-, RSASSA-PSS-, ECDSA-OID’s; `aes-256-cbc`, `aes-256-gcm`; RSA >= 2048, EC >= 256	`self`	Geen	Constructor is privé; presets zijn de enige ingang
`FipsCryptoPolicy::standard()`	`?FipsSelfTest $selfTest = null`	FIPS 140-2 preset: strikte set plus `aes-128-cbc`	`self`	Geen	Uitsluitend voor legacy-interoperabiliteit
`FipsCryptoPolicy::assertPreOperational()`	Geen	Draait, of herspeelt het vergrendelde resultaat van, de power-on batterij	`void`	`FipsModuleErrorStateException` wanneer een power-on test faalt	Aangedreven door de Core-enforcementnaad vóór de eerste operatie
`FipsCryptoPolicy` query-oppervlak	`string` / `int` inputs	Allow-list lidmaatschapscontroles; onbekend sleuteltype wordt geweigerd	`bool` / `string`	Geen	`isHashAlgorithmAllowed`, `isSignatureAlgorithmAllowed`, `isEncryptionAlgorithmAllowed`, `isKeyStrengthAllowed`, `getPreferredHashAlgorithm`, `getName`
`FipsModeGuard::__construct()`	`CryptoPolicyInterface $policy`, `?FipsBootGuard $bootGuard = null`, `?FipsAuditLogger $auditLogger = null`	Wikkelt een policy met assert-stijl grenzen	—	Geen	Zonder `$bootGuard` is er geen zelftestpoort; productiecompositie levert die aan
`FipsModeGuard::assertHashAllowed()`	`string $algorithm`	Eerst de weigercatalogus, dan de allow-list	`void`	`FipsViolationException`; `FipsModuleErrorStateException` wanneer een boot guard is bedraad	Auditrecord gaat vooraf aan elke `FipsViolationException`
`FipsModeGuard::assertSignatureAlgorithmAllowed()`	`string $oid`	Eerst de weigercatalogus, dan de allow-list	`void`	Zelfde als hierboven	OID’s worden exact gematcht
`FipsModeGuard::assertEncryptionAllowed()`	`string $algorithm`	Eerst de weigercatalogus, dan de allow-list	`void`	Zelfde als hierboven	Namen worden in kleine letters vergeleken
`FipsModeGuard::assertKeyStrengthAllowed()`	`string $keyType`, `int $bitLength`	Eerst de weigercatalogus, dan de policy-minima	`void`	Zelfde als hierboven	Onbekend sleuteltype wordt geweigerd
`FipsModeGuard::getPolicy()`	Geen	Retourneert de gewikkelde policy	`CryptoPolicyInterface`	Geen	—
`FipsBootGuard::__construct()`	`FipsSelfTest $selfTest`	Houdt de batterij vast; draait ze niet	—	Geen	Eén power-on cyclus per instantie
`FipsBootGuard::report()`	Geen	Draait de batterij eenmaal, cachet het rapport, vergrendelt bij fout	`FipsSelfTestReport`	Geen	Eerste aanroep draait de tests
`FipsBootGuard::rerun()`	Geen	Forceert een verse run; een gefaalde run vergrendelt het proces	`FipsSelfTestReport`	Geen	Zelftest op aanvraag; geen foutherstelpad
`FipsBootGuard::assertOperational()`	Geen	Asserteert dat de module operationeel is; plakkend over het proces	`void`	`FipsModuleErrorStateException`	Een schone instantie gooit nog steeds wanneer het proces een fout vergrendelde
`FipsBootGuard::status()`	Geen	Rapporteert de gecachete status	`FipsSelfTestStatus`	Geen	`ERROR` wanneer vergrendeld; `PRE_OPERATIONAL` wanneer nooit gedraaid
`FipsSelfTest::__construct()`	`?callable $randomBytesProvider = null`, `?callable $hashProvider = null`	Gebruikt platform `hash()` en `random_bytes()`	—	Geen	Overrides bestaan voor deterministische faaltests
`FipsSelfTest::run()`	Geen	Voert de volledige batterij uit; maakt nooit een kortsluiting	`FipsSelfTestReport`	Geen	Fouten landen in het rapport, niet in excepties
`FipsSelfTestReport`	`FipsSelfTestStatus $status`, `array $results`, `array $failedResults`	Onveranderlijk aggregaat van één run	—	`assertOperational()` gooit `FipsModuleErrorStateException` in de foutstatus	Ook `isOperational()`, `isError()`
`FipsSelfTestResult`	`string $algorithm`, `string $kind`, `bool $passed`, `string $message = ''`	Onveranderlijke uitkomst per test	—	Geen	`kind` is `KAT`, `PWCT` of `HEALTH`; ook `isPassed()`, `isFailed()`
`FipsSelfTestStatus`	—	String-backed enum	—	Geen	Cases `PRE_OPERATIONAL`, `OPERATIONAL`, `ERROR`
`FipsSignatureEnforcer::__construct()`	`FipsModeGuard $guard`	Wikkelt een boot-gated bewaking voor ondertekeningsknelpunten	—	Geen	—
`FipsSignatureEnforcer::assertSignatureGenerationAllowed()`	`string $algorithm`, `string $certificatePem`	Herleidt de OID en sleutelsterkte, delegeert dan naar de bewaking	`void`	`FipsViolationException` (onbekend algoritme, niet-goedgekeurde PSS-digest, onbewijsbare sleutel of policy-weigering); `FipsModuleErrorStateException` via de bewaking	Alleen het generatiepad; verificatie routeert hier nooit door
`FipsAuditLogger::__construct()`	`CryptoPolicyInterface $policy`, `LoggerInterface $logger`	Wikkelt een PSR-3 logger en dezelfde policy die de bewaking afdwingt	—	Geen	Vastgelegde beslissingen kunnen niet afwijken van afgedwongen beslissingen
`FipsAuditLogger::logHashOperation()` / `logSignatureOperation()` / `logEncryptionOperation()` / `logKeyStrengthCheck()`	`string` / `int` inputs per beslissing	Logt ALLOW op INFO en DENY op WARNING	`bool` (true wanneer toegestaan)	Geen	Gestructureerde context: policy-naam, item, beslissing
`FipsTransitioningAlgorithms`	`string` / `int` inputs	Statische SP 800-131A Rev.2 weigercatalogus	`bool` / `list<string>`	Geen	`isHashDisallowed`, `isSignatureOidDisallowed`, `isEncryptionDisallowed`, `isKeyStrengthDisallowed`, plus `disallowedHashes`, `disallowedSignatureOids`, `disallowedEncryption`
`FipsViolationException`	`string $policyName`, `string $violatingItem`, `string $reason`	Getypeerde policy-schending met publieke readonly velden	—	—	Subtype van `NextPDF\Exception\NextPdfException`
`FipsModuleErrorStateException`	`array $failedResults`, `?string $message = null`	Foutstatus-weigering die de gefaalde testresultaten meedraagt	—	—	Subtype van `NextPDF\Exception\NextPdfException`

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

public static function strict(?FipsSelfTest $selfTest = null): self
public static function standard(?FipsSelfTest $selfTest = null): self
public function assertPreOperational(): void
public function isHashAlgorithmAllowed(string $algorithm): bool
public function isSignatureAlgorithmAllowed(string $oid): bool
public function isEncryptionAlgorithmAllowed(string $algorithm): bool
public function isKeyStrengthAllowed(string $keyType, int $bitLength): bool
public function getPreferredHashAlgorithm(): string
public function getName(): string

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 function __construct(private readonly FipsSelfTest $selfTest)
public function report(): FipsSelfTestReport
public function rerun(): FipsSelfTestReport
public function assertOperational(): void
public function status(): FipsSelfTestStatus

public function __construct(?callable $randomBytesProvider = null, ?callable $hashProvider = null)
public function run(): FipsSelfTestReport

public function __construct(private readonly FipsModeGuard $guard)
public function assertSignatureGenerationAllowed(string $algorithm, string $certificatePem): void

public function __construct(private CryptoPolicyInterface $policy, private LoggerInterface $logger)
public function logHashOperation(string $algorithm): bool
public function logSignatureOperation(string $oid): bool
public function logEncryptionOperation(string $algorithm): bool
public function logKeyStrengthCheck(string $keyType, int $bitLength): bool

public static function isHashDisallowed(string $algorithm): bool
public static function isSignatureOidDisallowed(string $oid): bool
public static function isEncryptionDisallowed(string $algorithm): bool
public static function isKeyStrengthDisallowed(string $keyType, int $bitLength): bool
public static function disallowedHashes(): array
public static function disallowedSignatureOids(): array
public static function disallowedEncryption(): array

public function __construct(public FipsSelfTestStatus $status, public array $results, public array $failedResults)
public function isOperational(): bool
public function isError(): bool
public function assertOperational(): void

// FipsSelfTestResult
public function __construct(public string $algorithm, public string $kind, public bool $passed, public string $message = '')
public function isPassed(): bool
public function isFailed(): bool

// FipsSelfTestStatus
enum FipsSelfTestStatus: string
{
    case PRE_OPERATIONAL = 'pre_operational';
    case OPERATIONAL = 'operational';
    case ERROR = 'error';
}

Gedragscontract

De policy-allow-list is de gezaghebbende beslissing. FipsTransitioningAlgorithms voegt daarbovenop een expliciete SP 800-131A Rev.2 weigerlaag toe, voor audit-heldere afwijzingsberichten. De weigerlaag verbreedt of overschrijft de allow-list nooit.
FipsCryptoPolicy::strict() staat SHA-256, SHA-384 en SHA-512 toe; RSA PKCS#1 v1.5-, RSASSA-PSS- en ECDSA-handtekening-OID’s gebonden aan die hashes; aes-256-cbc en aes-256-gcm; en sleutelvloeren van RSA 2048, EC 256, Ed25519 256. standard() staat daarnaast aes-128-cbc toe.
De power-on batterij dekt: SHA-256/384/512 digest-KAT’s, een HMAC-SHA-256 KAT, een AES-256-CBC encrypt-en-decrypt KAT, een AES-256-GCM tag-KAT, een ECDSA P-256 paarsgewijze consistentietest, en een DRBG health-check. FipsSelfTest::run() voert altijd elke test uit en maakt nooit een kortsluiting, zodat het rapport volledig is als auditbewijs.
De DRBG-rij is een continue health-test (trekkingslengte plus verschillende opeenvolgende trekkingen), geen known-answer test. De DRBG known-answer verplichting wordt gedelegeerd aan de onderliggende FIPS-gevalideerde provider die de operator aanlevert.
De foutstatus is proces-plakkend. Het eerste ERROR-rapport dat door een FipsBootGuard wordt waargenomen, vergrendelt het hele proces. Een verse bewaking of policy-instantie kan de fout niet witwassen, en een latere slagende rerun wist ze niet. Alleen een procesherstart (een echte power-cyclus) reset de status.
FipsCryptoPolicy implementeert NextPDF\Contracts\CryptoPolicyInterface en NextPDF\Contracts\PreOperationalSelfTestInterface. Wanneer geconfigureerd als de Core-crypto-policy, drijft de Core-enforcementnaad assertPreOperational() aan voordat de eerste handtekening of ciphertext wordt geproduceerd.
FipsSignatureEnforcer bewaakt alleen het generatiepad. Verificatie van reeds gegenereerde handtekeningen is legacy-gebruik onder SP 800-131A Rev.2 en routeert nooit door de enforcer.
Wanneer een audit-logger is bedraad, zendt elke assert-grens één ALLOW (INFO)- of DENY (WARNING)-record uit voordat een policy-schending wordt gegooid. Elke FipsViolationException-weigering wordt dus in de trail bewezen. De boot-guard-poort draait eerst, zodat een foutstatus-weigering wordt opgeworpen vóór het auditrecord. De FipsAuditLogger raadpleegt dezelfde policy die de bewaking afdwingt, zodat vastgelegde beslissingen niet kunnen afwijken van afgedwongen beslissingen.

Randgevallen en faalmodi

Een onbekend sleuteltype wordt door beide lagen geweigerd: de policy retourneert false en de catalogus behandelt het als niet-toegestaan.
Een ondertekeningsalgoritme-identifier die de enforcer niet naar een handtekening-OID kan mappen, wordt fail-closed geweigerd met FipsViolationException.
Elke RSASSA-PSS-variant deelt de OID 1.2.840.113549.1.1.10, zodat de OID alleen de digest niet kan bewijzen. De enforcer bindt de effectieve digest expliciet en weigert elk PSS-token waarvan de digest geen SHA-256/384/512 is.
Een certificaat dat niet kan worden geparseerd, of waarvan de bitlengte van de publieke sleutel onbeschikbaar is, wordt geweigerd als key:unprovable.
Op een runtime zonder OpenSSL asymmetrische primitieven registreert de ECDSA paarsgewijze consistentietest een fout, geen skip, en de module gaat over naar ERROR.
Twee identieke opeenvolgende 32-byte willekeurige trekkingen falen de DRBG health-check (stuck-output detectie) en forceren ERROR.
Een FipsModeGuard geconstrueerd zonder boot guard voert alleen policy-controles uit en heeft geen zelftestpoort. Productiecompositie gaat via FipsBootstrap, die de poort altijd bedraadt.
Hash- en cipher-namen worden in kleine letters vergeleken; handtekening-OID’s worden exact gematcht, zonder normalisatie.
Na FipsBootstrap::lazy() blijft de module PRE_OPERATIONAL totdat de eerste assert-grens de batterij draait. PRE_OPERATIONAL wordt op het moment van assertie als niet-operationeel behandeld.

FIPS-modus gedrag

Deze module is het FIPS-modus oppervlak zelf. Terwijl de module in de foutstatus is, en terwijl pre-operationele zelftests draaien, wordt cryptografische output verhinderd: elke assert-grens gooit FipsModuleErrorStateException voordat een handtekening of ciphertext wordt geproduceerd (ISO/IEC 19790:2025 §7.3.3 b), AS03.07). FipsBootGuard::status() en FipsBootstrap::selfTestReport() stellen de status bloot zodat een operator kan bepalen dat de module de foutstatus binnenging (ISO/IEC 19790:2025 §7.10.3). Deze gedragingen zijn capaciteitsclaims over NextPDF-code, geen validatieclaim: de modulegrens die FIPS 140 valideert is de door de operator aangeleverde cryptografische provider, niet NextPDF.

Conformiteit

Claim	Standaard	Clausule
FIPS 140-3 is gebaseerd op ISO/IEC 19790 en ISO/IEC 24759; deze pagina citeert daarom ISO/IEC 19790-clausules.	FIPS 140-3	Introduction (fips_140_3#x26.x2)
Output wordt verhinderd in de foutstatus en tijdens pre-operationele zelftests.	ISO/IEC 19790:2025	§7.3.3 b) [AS03.07]
Een known-answer test vergelijkt een berekend resultaat met een bekende verwachte output; de batterij implementeert deze vorm.	ISO/IEC 19790:2025	§7.10.4
De operator kan de foutstatus bepalen via een status-output.	ISO/IEC 19790:2025	§7.10.3 [AS10.10]
Operators kunnen de zelftests op aanvraag initiëren voor periodieke tests; `rerun()` en `selfTestReport()` bieden dit.	ISO/IEC 19790:2025	§7.10.5 [AS10.54]
SHA-1 is niet toegestaan voor nieuwe digitale-handtekeninggeneratie; de weigercatalogus wijst het af.	NIST SP 800-131A Rev.2	§9
Handtekeninggeneratie onder 112-bit sterkte (RSA < 2048, ECDSA-order < 224) is niet toegestaan; de sleutelvloeren dwingen dit af.	NIST SP 800-131A Rev.2	§3 Table 2
Verificatie van reeds gegenereerde SHA-1-handtekeningen is legacy-gebruik; het routeert niet door de generatiepoort.	NIST SP 800-131A Rev.2	Change summary (9.x4.p12)

Alle clausules zijn geparafraseerd; er wordt geen normatieve tekst gereproduceerd. NextPDF maakt geen FIPS 140-certificeringsclaim. De module stemt haar gedrag af op de geciteerde clausules als een compliance-assistentie capaciteit. Of een deployment FIPS-compliant is, hangt af van de gevalideerde provider van de operator, de definitie van de modulegrens en het complianceprogramma — niet van NextPDF alleen.

Ontwikkelnotities

Deterministische faaltests injecteren kapotte providers via de FipsSelfTest-constructor, of via de $selfTest-parameters op FipsCryptoPolicy::strict(), standard() en de FipsBootstrap-methoden.
De proces-plakkende foutvergrendeling heeft een interne, test-only reset-hook. Die is geen onderdeel van de ondersteunde API, en productiecode mag hem niet aanroepen.
Elk PHP-workerproces draait zijn eigen power-on batterij. Het rapport wordt per instantie gecachet, zodat hot-path asserties constant-tijd statuscontroles zijn.
Vang FipsModuleErrorStateException niet af en ga niet door. De exceptie betekent dat de module cryptografische diensten weigert; de juiste reactie is stoppen en het proces herstarten na remediatie.
FipsBootstrap::selfTestReport() bedient zelftestbehoeften op aanvraag en periodiek, zoals health-endpoints. Een slagende run op aanvraag wist nooit een vergrendelde fout.

Zie ook

FIPS 140-2/3 cryptografische policy en zelftest — de capaciteitspagina met setup en voorbeelden.
Security — Uitgebreide referentie — de gecombineerde Enterprise-securitycontroles.
Signature — Uitgebreide referentie — de PAdES long-term producer en zijn FIPS-modus notitie.
Security — NextPDF Core — het Core-encryptie- en ondertekeningsoppervlak waaraan de policy zich bindt.

Publicatiegrens

Deze pagina documenteert alleen extern waarneembaar gedrag en het ondersteunde publieke API-oppervlak. Interne namespace-paden, helper-klassen, mechanismetabellen, runbook-bestandsnamen en ticket-prefixen vallen buiten de scope.