Enterprise édition

FIPS 140 — Référence détaillée

En bref

Cette page constitue la référence détaillée du module FIPS 140 de NextPDF Enterprise. Le module est une capacité de politique et d’autotest. Il restreint les choix cryptographiques à une liste d’autorisation alignée sur FIPS, exécute une batterie de tests à réponse connue au démarrage et inhibe la sortie cryptographique lorsque la batterie échoue. NextPDF n’est pas un module cryptographique validé FIPS 140, ne détient aucune certification et n’en confère aucune. La prise en charge n’équivaut pas à la conformité, et la conformité n’équivaut pas à la certification. Un déploiement compatible FIPS requiert en outre un fournisseur cryptographique validé FIPS fourni par l’exploitant.

Disponibilité et licence

Cette capacité est fournie dans NextPDF Enterprise (nextpdf/enterprise) et s’active avec une enveloppe de licence de niveau Enterprise. Un déploiement dépourvu de ce droit ne charge pas les classes de la capacité. Comparer les éditions et obtenir une licence.

Surface de l’API publique

Tous les symboles résident dans NextPDF\Enterprise\Security\Fips, à l’exception de FipsBootstrap dans NextPDF\Enterprise\Bootstrap.

Symbole	Paramètres	Comportement par défaut	Renvoie	Lève ou échoue avec	Notes
`FipsBootstrap::boot()`	`?CryptoPolicyInterface $policy`, `?FipsSelfTest $selfTest`, `?LoggerInterface $auditLogger` (toutes par défaut `null`)	Exécute la batterie de démarrage une fois au lancement ; par défaut, la politique stricte	`FipsModeGuard`	`FipsModuleErrorStateException` en cas d’échec d’un test de démarrage	Racine de composition ; piste d’audit désactivée lorsque `$auditLogger` vaut `null`
`FipsBootstrap::lazy()`	Identiques à `boot()`	Diffère la batterie jusqu’à la première assertion de frontière	`FipsModeGuard`	Aucune à l’appel ; la première assertion peut lever `FipsModuleErrorStateException`	Le module reste `PRE_OPERATIONAL` jusqu’à la première assertion
`FipsBootstrap::signatureEnforcer()`	`?CryptoPolicyInterface $policy = null`, `?FipsSelfTest $selfTest = null`	Démarre le module, puis enveloppe le garde pour les points de passage de signature	`FipsSignatureEnforcer`	`FipsModuleErrorStateException` en cas d’échec d’un test de démarrage	Délègue à `boot()`
`FipsBootstrap::selfTestReport()`	`?FipsSelfTest $selfTest = null`	Exécute la batterie à la demande et la résume	`array{status: FipsSelfTestStatus, operational: bool, failed: list<string>}`	Ne lève pas ; les échecs apparaissent dans `failed`	Pour les points de terminaison de santé d’administration et l’usage en CLI
`FipsCryptoPolicy::strict()`	`?FipsSelfTest $selfTest = null`	Préréglage FIPS 140-3 : SHA-256/384/512 ; OID RSA, RSASSA-PSS, ECDSA approuvés ; `aes-256-cbc`, `aes-256-gcm` ; RSA >= 2048, EC >= 256	`self`	Aucune	Le constructeur est privé ; les préréglages sont le seul point d’entrée
`FipsCryptoPolicy::standard()`	`?FipsSelfTest $selfTest = null`	Préréglage FIPS 140-2 : ensemble strict plus `aes-128-cbc`	`self`	Aucune	Interopérabilité héritée uniquement
`FipsCryptoPolicy::assertPreOperational()`	Aucun	Exécute la batterie de démarrage, ou en rejoue le résultat verrouillé	`void`	`FipsModuleErrorStateException` lorsqu’un test de démarrage échoue	Piloté par la couture d’imposition du Core avant la première opération
Surface de requête de `FipsCryptoPolicy`	Entrées `string` / `int`	Vérifications d’appartenance à la liste d’autorisation ; un type de clé inconnu est refusé	`bool` / `string`	Aucune	`isHashAlgorithmAllowed`, `isSignatureAlgorithmAllowed`, `isEncryptionAlgorithmAllowed`, `isKeyStrengthAllowed`, `getPreferredHashAlgorithm`, `getName`
`FipsModeGuard::__construct()`	`CryptoPolicyInterface $policy`, `?FipsBootGuard $bootGuard = null`, `?FipsAuditLogger $auditLogger = null`	Enveloppe une politique de frontières de type assertion	—	Aucune	Sans `$bootGuard`, il n’y a pas de barrière d’autotest ; la composition de production le fournit
`FipsModeGuard::assertHashAllowed()`	`string $algorithm`	Le catalogue de refus d’abord, puis la liste d’autorisation	`void`	`FipsViolationException` ; `FipsModuleErrorStateException` lorsqu’un garde de démarrage est câblé	L’enregistrement d’audit précède toute `FipsViolationException`
`FipsModeGuard::assertSignatureAlgorithmAllowed()`	`string $oid`	Le catalogue de refus d’abord, puis la liste d’autorisation	`void`	Comme ci-dessus	Les OID sont mis en correspondance à l’identique
`FipsModeGuard::assertEncryptionAllowed()`	`string $algorithm`	Le catalogue de refus d’abord, puis la liste d’autorisation	`void`	Comme ci-dessus	Les noms sont comparés en minuscules
`FipsModeGuard::assertKeyStrengthAllowed()`	`string $keyType`, `int $bitLength`	Le catalogue de refus d’abord, puis les minimums de la politique	`void`	Comme ci-dessus	Un type de clé inconnu est refusé
`FipsModeGuard::getPolicy()`	Aucun	Renvoie la politique enveloppée	`CryptoPolicyInterface`	Aucune	—
`FipsBootGuard::__construct()`	`FipsSelfTest $selfTest`	Détient la batterie ; ne l’exécute pas	—	Aucune	Un cycle de démarrage par instance
`FipsBootGuard::report()`	Aucun	Exécute la batterie une fois, met le rapport en cache, se verrouille en cas d’erreur	`FipsSelfTestReport`	Aucune	Le premier appel exécute les tests
`FipsBootGuard::rerun()`	Aucun	Force une nouvelle exécution ; une exécution en erreur verrouille le processus	`FipsSelfTestReport`	Aucune	Autotest à la demande ; pas un chemin de récupération d’erreur
`FipsBootGuard::assertOperational()`	Aucun	Affirme que le module est opérationnel ; persistant sur tout le processus	`void`	`FipsModuleErrorStateException`	Une instance propre lève tout de même lorsque le processus a verrouillé une erreur
`FipsBootGuard::status()`	Aucun	Signale le statut mis en cache	`FipsSelfTestStatus`	Aucune	`ERROR` lorsqu’il est verrouillé ; `PRE_OPERATIONAL` lorsqu’il n’a jamais été exécuté
`FipsSelfTest::__construct()`	`?callable $randomBytesProvider = null`, `?callable $hashProvider = null`	Utilise les fonctions `hash()` et `random_bytes()` de la plateforme	—	Aucune	Des surcharges existent pour les tests d’échec déterministes
`FipsSelfTest::run()`	Aucun	Exécute la batterie complète ; ne court-circuite jamais	`FipsSelfTestReport`	Aucune	Les échecs se retrouvent dans le rapport, pas dans des exceptions
`FipsSelfTestReport`	`FipsSelfTestStatus $status`, `array $results`, `array $failedResults`	Agrégat immuable d’une exécution	—	`assertOperational()` lève `FipsModuleErrorStateException` dans l’état d’erreur	Également `isOperational()`, `isError()`
`FipsSelfTestResult`	`string $algorithm`, `string $kind`, `bool $passed`, `string $message = ''`	Résultat immuable par test	—	Aucune	`kind` vaut `KAT`, `PWCT` ou `HEALTH` ; également `isPassed()`, `isFailed()`
`FipsSelfTestStatus`	—	Énumération adossée à une chaîne	—	Aucune	Cas `PRE_OPERATIONAL`, `OPERATIONAL`, `ERROR`
`FipsSignatureEnforcer::__construct()`	`FipsModeGuard $guard`	Enveloppe un garde barré au démarrage pour les points de passage de signature	—	Aucune	—
`FipsSignatureEnforcer::assertSignatureGenerationAllowed()`	`string $algorithm`, `string $certificatePem`	Résout l’OID et la robustesse de clé, puis délègue au garde	`void`	`FipsViolationException` (algorithme inconnu, condensé PSS non approuvé, clé non prouvable ou refus de politique) ; `FipsModuleErrorStateException` via le garde	Chemin de génération uniquement ; la vérification ne passe jamais par ici
`FipsAuditLogger::__construct()`	`CryptoPolicyInterface $policy`, `LoggerInterface $logger`	Enveloppe un logger PSR-3 et la même politique que celle imposée par le garde	—	Aucune	Les décisions enregistrées ne peuvent pas diverger de celles imposées
`FipsAuditLogger::logHashOperation()` / `logSignatureOperation()` / `logEncryptionOperation()` / `logKeyStrengthCheck()`	Entrées `string` / `int` selon la décision	Journalise ALLOW en INFO et DENY en WARNING	`bool` (true lorsque autorisé)	Aucune	Contexte structuré : nom de la politique, élément, décision
`FipsTransitioningAlgorithms`	Entrées `string` / `int`	Catalogue de refus statique SP 800-131A Rev.2	`bool` / `list<string>`	Aucune	`isHashDisallowed`, `isSignatureOidDisallowed`, `isEncryptionDisallowed`, `isKeyStrengthDisallowed`, plus `disallowedHashes`, `disallowedSignatureOids`, `disallowedEncryption`
`FipsViolationException`	`string $policyName`, `string $violatingItem`, `string $reason`	Violation de politique typée avec des champs publics readonly	—	—	Sous-type de `NextPDF\Exception\NextPdfException`
`FipsModuleErrorStateException`	`array $failedResults`, `?string $message = null`	Refus d’état d’erreur portant les résultats de tests échoués	—	—	Sous-type de `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';
}

Contrat de comportement

La liste d’autorisation de la politique constitue la décision qui fait autorité. FipsTransitioningAlgorithms ajoute au-dessus d’elle une couche de refus SP 800-131A Rev.2 explicite, pour des messages de rejet clairs à l’audit. La couche de refus n’élargit ni ne remplace jamais la liste d’autorisation.
FipsCryptoPolicy::strict() autorise SHA-256, SHA-384 et SHA-512 ; les OID de signature RSA PKCS#1 v1.5, RSASSA-PSS et ECDSA liés à ces hachages ; aes-256-cbc et aes-256-gcm ; ainsi que des planchers de clé de RSA 2048, EC 256, Ed25519 256. standard() autorise en plus aes-128-cbc.
La batterie de démarrage couvre : les KAT de condensé SHA-256/384/512, un KAT HMAC-SHA-256, un KAT de chiffrement-déchiffrement AES-256-CBC, un KAT d’étiquette AES-256-GCM, un test de cohérence par paire ECDSA P-256 et un contrôle de santé DRBG. FipsSelfTest::run() exécute toujours chaque test et ne court-circuite jamais, de sorte que le rapport est complet en tant que preuve d’audit.
La ligne DRBG est un test de santé continu (longueur de tirage plus tirages successifs distincts), et non un test à réponse connue. L’obligation de réponse connue du DRBG est déléguée au fournisseur validé FIPS sous-jacent que l’exploitant fournit.
L’état d’erreur est persistant au niveau du processus. Le premier rapport ERROR observé par un quelconque FipsBootGuard verrouille l’ensemble du processus. Une nouvelle instance de garde ou de politique ne peut pas blanchir l’erreur, et une nouvelle exécution réussie ultérieure ne l’efface pas. Seul un redémarrage du processus (un véritable cycle d’alimentation) réinitialise l’état.
FipsCryptoPolicy implémente NextPDF\Contracts\CryptoPolicyInterface et NextPDF\Contracts\PreOperationalSelfTestInterface. Lorsqu’elle est configurée comme politique cryptographique du Core, la couture d’imposition du Core pilote assertPreOperational() avant que la première signature ou le premier texte chiffré ne soit produit.
FipsSignatureEnforcer barre uniquement le chemin de génération. La vérification de signatures déjà générées est un usage hérité au sens de SP 800-131A Rev.2 et ne passe jamais par l’imposeur.
Lorsqu’un journaliseur d’audit est câblé, chaque frontière d’assertion émet un enregistrement ALLOW (INFO) ou DENY (WARNING) avant toute levée pour violation de politique. Chaque refus FipsViolationException est donc attesté dans la piste. La barrière du garde de démarrage s’exécute en premier, de sorte qu’un refus d’état d’erreur est levé avant l’enregistrement d’audit. Le FipsAuditLogger consulte la même politique que celle imposée par le garde, de sorte que les décisions enregistrées ne peuvent pas diverger de celles imposées.

Cas limites et modes de défaillance

Un type de clé inconnu est refusé par les deux couches : la politique renvoie false et le catalogue le traite comme interdit.
Un identifiant d’algorithme de signature que l’imposeur ne peut pas faire correspondre à un OID de signature est refusé en mode fail-closed avec FipsViolationException.
Chaque variante RSASSA-PSS partage l’OID 1.2.840.113549.1.1.10, de sorte que l’OID seul ne peut pas prouver le condensé. L’imposeur lie explicitement le condensé effectif et refuse tout jeton PSS dont le condensé n’est pas SHA-256/384/512.
Un certificat qui ne peut pas être analysé, ou dont la longueur en bits de la clé publique est indisponible, est refusé en tant que key:unprovable.
Sur un environnement d’exécution dépourvu de primitives asymétriques OpenSSL, le test de cohérence par paire ECDSA enregistre un échec, non un saut, et le module passe en ERROR.
Deux tirages aléatoires successifs identiques de 32 octets échouent au contrôle de santé DRBG (détection de sortie bloquée) et forcent ERROR.
Un FipsModeGuard construit sans garde de démarrage n’effectue que des vérifications de politique et n’a pas de barrière d’autotest. La composition de production passe par FipsBootstrap, qui câble toujours la barrière.
Les noms de hachage et de chiffrement sont comparés en minuscules ; les OID de signature sont mis en correspondance à l’identique, sans normalisation.
Après FipsBootstrap::lazy(), le module reste PRE_OPERATIONAL jusqu’à ce que la première frontière d’assertion exécute la batterie. PRE_OPERATIONAL est traité comme non opérationnel au moment de l’assertion.

Comportement en mode FIPS

Ce module est la surface du mode FIPS elle-même. Tant que le module est dans l’état d’erreur, et tant que les autotests préopérationnels s’exécutent, la sortie cryptographique est inhibée : chaque frontière d’assertion lève FipsModuleErrorStateException avant qu’une signature ou un texte chiffré ne soit produit (ISO/IEC 19790:2025 §7.3.3 b), AS03.07). FipsBootGuard::status() et FipsBootstrap::selfTestReport() exposent l’état afin qu’un exploitant puisse déterminer que le module est entré dans l’état d’erreur (ISO/IEC 19790:2025 §7.10.3). Ces comportements sont des revendications de capacité concernant le code NextPDF, non une revendication de validation : la frontière de module que FIPS 140 valide est le fournisseur cryptographique fourni par l’exploitant, non NextPDF.

Conformité

Revendication	Norme	Clause
FIPS 140-3 est fondée sur ISO/IEC 19790 et ISO/IEC 24759 ; cette page cite donc des clauses ISO/IEC 19790.	FIPS 140-3	Introduction (fips_140_3#x26.x2)
La sortie est inhibée dans l’état d’erreur et pendant les autotests préopérationnels.	ISO/IEC 19790:2025	§7.3.3 b) [AS03.07]
Un test à réponse connue compare un résultat calculé à une sortie attendue connue ; la batterie met en œuvre cette forme.	ISO/IEC 19790:2025	§7.10.4
L’exploitant peut déterminer l’état d’erreur au moyen d’une sortie de statut.	ISO/IEC 19790:2025	§7.10.3 [AS10.10]
Les exploitants peuvent lancer les autotests à la demande pour des tests périodiques ; `rerun()` et `selfTestReport()` le permettent.	ISO/IEC 19790:2025	§7.10.5 [AS10.54]
SHA-1 est interdit pour la génération de nouvelles signatures numériques ; le catalogue de refus le rejette.	NIST SP 800-131A Rev.2	§9
La génération de signatures en deçà d’une robustesse de 112 bits (RSA < 2048, ordre ECDSA < 224) est interdite ; les planchers de clé l’imposent.	NIST SP 800-131A Rev.2	§3 Table 2
La vérification de signatures SHA-1 déjà générées est un usage hérité ; elle ne passe pas par la barrière de génération.	NIST SP 800-131A Rev.2	Change summary (9.x4.p12)

Toutes les clauses sont paraphrasées ; aucun texte normatif n’est reproduit. NextPDF ne formule aucune revendication de certification FIPS 140. Le module aligne son comportement sur les clauses citées en tant que capacité d’assistance à la conformité. Qu’un déploiement soit conforme à FIPS dépend du fournisseur validé de l’exploitant, de la définition de la frontière de module et de son programme de conformité — non de NextPDF seul.

Notes de développement

Les tests d’échec déterministes injectent des fournisseurs défectueux via le constructeur FipsSelfTest, ou via les paramètres $selfTest de FipsCryptoPolicy::strict(), standard() et des méthodes FipsBootstrap.
Le verrou d’erreur persistant au niveau du processus dispose d’un point de réinitialisation interne réservé aux tests. Il ne fait pas partie de l’API prise en charge, et le code de production ne doit pas l’appeler.
Chaque processus de travail PHP exécute sa propre batterie de démarrage. Le rapport est mis en cache par instance, de sorte que les assertions du chemin critique sont des vérifications de statut à temps constant.
Ne capture pas FipsModuleErrorStateException pour poursuivre. L’exception signifie que le module refuse les services cryptographiques ; la réponse correcte est d’arrêter puis de redémarrer le processus après remédiation.
FipsBootstrap::selfTestReport() répond aux besoins d’autotest à la demande et périodiques, tels que les points de terminaison de santé. Une exécution à la demande réussie n’efface jamais une erreur verrouillée.

Voir aussi

Politique cryptographique FIPS 140-2/3 et autotest — la page de capacité avec configuration et exemples.
Sécurité — Référence détaillée — les contrôles de sécurité Enterprise combinés.
Signature — Référence détaillée — le producteur PAdES à long terme et sa note sur le mode FIPS.
Sécurité — NextPDF Core — la surface de chiffrement et de signature du Core à laquelle la politique se lie.

Périmètre de publication

Cette page documente uniquement le comportement observable de l’extérieur et la surface de l’API publique prise en charge. Les chemins d’espaces de noms internes, les classes auxiliaires, les tables de mécanismes, les noms de fichiers de runbook et les préfixes de tickets sont hors périmètre.