@blamejs/pki 0.7.25 → 0.7.27

package/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable changes to `@blamejs/pki` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.7.27 — 2026-09-12
+
+pki lint detects a certificate, a CRL or an OCSP response and runs the matching profile.
+
+### Added
+
+- pki lint <file> detects whether the file holds a certificate, a CRL or an OCSP response, as DER or PEM, and lints it with pki.lint.certificate, pki.lint.crl or pki.lint.ocsp. --profile, --severity and --json apply to whichever verb runs, and a profile that belongs to another structure is refused with the message naming the verb that takes it. For a file holding a structure no profile covers (a certificate request, a CMS message, a key), the command reports the name the detector gives it and exits instead of linting it as a certificate.
+- lint/rfc5280/extension-criticality (error) reports a certificate extension marked critical that RFC 5280 requires a conforming CA to mark non-critical: authorityKeyIdentifier (section 4.2.1.1), subjectKeyIdentifier (4.2.1.2), subjectDirectoryAttributes (4.2.1.8), freshestCRL (4.2.1.15), authorityInfoAccess (4.2.2.1) and subjectInfoAccess (4.2.2.2). Each finding names the extension and its clause.
+
+### Changed
+
+- A certificate marking one of those six extensions critical was reported as lint/rfc5280/unknown-critical-extension, which told an operator the extension was not recognized when the defect was its criticality. The profile recognizes them, so that finding no longer fires for them; the new row does, at the same severity, so a report filtered at error is unchanged in its verdict and changed in its name.
+- The table of extensions whose criticality RFC 5280 and RFC 6962 fix now lives once, in the shared PKIX schema module, and both pki.x509.sign (which refuses to write against it) and pki.lint.certificate (which reports against it) read it from there.
+
+## v0.7.26 — 2026-09-12
+
+An OCSP response can be linted against RFC 6960, and against the RFC 5019 lightweight profile on request.
+
+### Added
+
+- pki.lint.ocsp(pem | der | parsed, opts) lints an OCSP response under the rfc6960 profile: a SingleResponse whose thisUpdate follows its nextUpdate, a producedAt earlier than a thisUpdate it certifies, a certs field that is present and empty, the extended revoked definition (its criticality, its NULL value, and that it belongs in responseExtensions), the fixed shape RFC 6960 section 2.2 gives a revoked answer for a non-issued certificate (certificateHold at January 1, 1970) and what that answer must and must not carry, the list each extension belongs in (the nonce, the archive cutoff, the CRL references, and the three extensions defined for requests only), an archive cutoff later than producedAt, the criticality and value syntax of the CRL entry extensions section 4.4.5 lets a SingleResponse carry, an unrecognized critical extension on either list, the revocation reasons unspecified and removeFromCRL, and two SingleResponses answering for one CertID. Each finding names the SingleResponse it is about.
+- The rfc5019 profile holds a response to the lightweight rules (nextUpdate always present, one SingleResponse, no responseExtensions, a byKey ResponderID). Nothing in a response says which profile its responder follows, so these rows run when profile: "rfc5019" is selected and count as not applicable in the default run.
+- pki.schema.ocsp.parseResponse reports certsPresent beside certs, so a reader can tell a response that carried an empty certs field from one that omitted it.
+- A lint-ocsp fuzz target drives the never-throw promise with hostile bytes on the ingestion boundary, spliced into a real response, and as the value of every extension the profile decodes.
+- All three lint verbs report a signature field that carries no signature (lint/rfc5280/signature-empty, lint/rfc5280-crl/signature-empty, lint/rfc6960/signature-empty). An empty BIT STRING is well-formed DER, so the strict parsers admit it and the profiles grade it.
+
+### Changed
+
+- The three lint verbs refuse each other's profile names with a message naming the verb that takes the profile, and pki.lint.profiles() and pki.lint.rules() enumerate the two OCSP profiles beside the certificate and CRL ones.
+
 ## v0.7.25 — 2026-09-12
 
 An OCSP response can say how far back its status reaches and which CRL it came from.

package/README.md

@@ -252,10 +252,10 @@ comment blocks, is at [pkijs.com](https://pkijs.com).
 | `pki.sigstore` | Offline verifier for a Sigstore bundle, the artifact `npm publish --provenance` produces and the registry serves. `verifyBundle` composes five fail-closed legs against caller-pinned trust (Fulcio CA roots and Rekor log keys, never trusted from the bundle): the DSSE signature over its PAE preimage under the Fulcio leaf key, the ephemeral Fulcio certificate chain validated as of the Rekor log time, the RFC 9162 inclusion proof folded to a Rekor-signed tree root, the log entry bound to this exact signature, and the in-toto SLSA subject digest the caller confirms against the published artifact. It reuses the X.509 parser, the RFC 5280 path validator, and the Merkle verifier; the net-new codecs are the DSSE PAE byte-builder and a fail-closed JSON reader. `verified: true` says the artifact was signed and logged, not that a party you trust signed it — Fulcio issues to anyone who completes an OIDC flow, so who signed is decided only by `opts.identity`, and `identityChecked` reports which of its fields were compared. An identity policy naming no field, or a field name that is not one of the three, is refused rather than satisfied — either would accept every signer while reading as a policy in force. A sixth leg is opt-in: pinning the certificate-transparency logs in `opts.ctLogs` checks the receipt Fulcio embeds in the certificate it issues (RFC 6962 §3.2), verified over the certificate as it stood before the receipt was added and under the key of the log that issued it, so the verdict says the signing certificate was public when it was issued rather than handed out quietly. At least one receipt must verify against a pinned log, the verdict reports `sctChecked` and `validScts`, and an empty log set is refused rather than read as a policy that checks nothing. Both content arms are read: a DSSE-wrapped in-toto attestation, and a message signature over an artifact's own bytes, which `cosign sign-blob` produces. For that arm `opts.artifact` supplies the bytes, and they are held to the hash the Rekor `hashedrekord` entry records before the signature is checked over them; the `messageDigest` the bundle carries is covered by no signature, so it is compared against the computed digest and never used in its place. `contentType` names the arm and the verdict has one shape for both — `pae`, `parseBundle`, `verifyBundle` |
 | `pki.inspect` | Human-readable inspection, the pure-JS equivalent of `openssl x509/crl/req/cms -text`. `certificate(pem \| der \| parsed)` renders an OpenSSL-style report: version, serial, signature algorithm, issuer and subject distinguished names, validity, public-key details (curve or modulus size plus the raw point or modulus), every decoded extension with its critical flag, and the signature. `crl`, `csr`, and `cms` render the other formats the same way — a CRL like `openssl crl -text`, a CSR like `openssl req -text`, and a CMS message like `openssl cms -cmsout -print`, with a stable summary for a non-SignedData ContentInfo — and `any(input)` detects the format and routes to the right report. Built over the strict parsers and the two-way OID registry with one set of field renderers, it names extension and algorithm OIDs an OpenSSL build shows only as raw bytes. No OpenSSL dependency, and the format is stable and OpenSSL-familiar rather than pinned to one OpenSSL version. A certificate policy's user notice renders as text, both its explicit text and a notice reference with the notice numbers that identify it, rather than hex, and a malformed part falls back to a hex dump rather than throwing — `certificate`, `crl`, `csr`, `cms`, `any` |
 | `pki.webauthn` | WebAuthn and passkey verification, both halves: offline trust evaluation of a W3C WebAuthn (Level 3) registration, and signature verification of the assertion every login returns. `parseAttestationObject(bytes)` decodes the CBOR attestation object, authenticatorData, and COSE credential key over the strict `pki.cbor` codec; `parseAuthenticatorData(bytes)` reads the bare form an assertion carries through the same parser; `parseClientData(bytes, opts)` decodes the `clientDataJSON` no signature check looks inside, through the shared JSON guard since these are attacker-chosen bytes, returning the challenge decoded so a caller compares bytes rather than spellings, and checking the ceremony type, challenge, and origin when the relying party supplies what it issued. `verifyAssertion(input)` verifies an assertion signature over `authenticatorData \|\| SHA-256(clientDataJSON)` — raw bytes, no COSE_Sign1, an ES256 signature in ASN.1 DER — and applies the §7.2 step 21 counter rule when a stored `previousSignCount` is given, so a counter that fails to advance is refused as a cloned authenticator. `verify(attestationObject, clientDataHash, opts)` checks the attestation-statement signature and each format's structural bindings for packed, tpm, android-key, apple, fido-u2f, and none: the x5c leaf key, the apple nonce, the tpm `certInfo` Name and `extraData` over the `pubArea`, the android `KeyDescription`, and the fido-u2f `verificationData`. It binds the credential public key to each attestation, through the signed authenticatorData for packed and fido-u2f or a cert or `pubArea`-key equality check for android-key, apple, and tpm, and enforces each leaf's certificate requirements. The credential-key check covers the full WebAuthn COSE algorithm set — ES256/384/512, RS256/384/512, PS256/384/512, EdDSA (Ed25519), and the RFC 9864 fully-specified identifiers ESP256/384/512, Ed25519, and Ed448 — validating the public-key point on its curve, rejecting the compressed EC point form, and enforcing a minimally encoded DER ECDSA signature. The verdict field is `attestationVerified`, and `signatureVerified` for an assertion, rather than a bare `verified`, because a sound statement is a different claim from an acceptable ceremony: an attestation naming another origin's RP ID with user presence clear is perfectly sound and must not be registered. Pass `expectedRpId`, `requireUserPresence`, `requireUserVerification`, or `allowedAlgorithms` and those are checked, with `bindingChecked` reporting which ran, so a check that passed can be told from one that never happened. Pass `opts.clientDataJSON` instead of the digest and the client data is read here too: the ceremony type is checked unconditionally, since a login response replayed into a registration is what that rule stops, and the challenge, origin, and top-level origin are checked against what the relying party issued, with `clientData.checked` reporting which comparisons ran. A registration verdict also carries the `credentialId`, `credentialPublicKey`, and initial `signCount` a later login needs. A credential key declaring COSE algorithm `-65535` (RSASSA-PKCS1-v1_5 with SHA-1) is refused unless `allowedAlgorithms` names it, since every signature that credential ever makes would use SHA-1. Anchoring the trust path has two routes: `opts.metadata` resolves the roots the authenticator's own model registered, and `opts.rootCertificates` pins roots directly, which is what anchors the formats FIDO MDS does not cover, Apple's authenticators and the Google hardware-attestation roots among them. `metadata` governs when both are given, and `anchoredTo` names every route that anchored the path, joined with `+` when more than one did: `"metadata"`, `"rootCertificates"`, and `"safetyNetRoots"` for the android-safetynet chain, which anchors through the roots that format requires whether or not either other route was asked for. It is `null` only when nothing anchored the path. `verifyMetadataBlob(blob, opts)` reads a FIDO Metadata Service (MDS v3) BLOB, the signed catalogue of registered authenticator models, verifying its JWS and chaining its signer to an operator-supplied FIDO root before the payload is parsed, with sequence-number rollback and `nextUpdate` freshness checks. Passing the result as `opts.metadata` to `verify` resolves the authenticator's registered attestation roots from its identifier and requires the trust path to fully validate to one of them, refusing an unlisted or revoked model. `metadataAnchors(entry, opts)` applies the same status gate for a caller anchoring the path themselves: a model the catalogue has disqualified registers no anchors. Both of the catalogue's key spaces are covered: an aaguid, and the attestation-certificate key identifiers a U2F authenticator is listed under instead. No FIDO root is bundled, there is no trust-on-first-use, and retrieving the BLOB is out of scope. Fail-closed with typed `webauthn/*` errors — `parseAttestationObject`, `verify`, `verifyMetadataBlob`, `metadataFor`, `metadataAnchors` |
-| `pki.lint` | Certificate linting, the zlint or pkilint of JavaScript. `certificate(pem \| der \| parsed, opts)` walks a parsed certificate and emits graded advisory findings, each with a stable id, a severity (`fatal`, `error`, `warn`, `notice`), a source, a spec-clause citation, and a message, against the RFC 5280 profile, the post-quantum certificate profiles, and a representative CA/Browser Forum TLS BR subset: serial sign and size, validity ordering and the SC081v3 reducing validity schedule, keyCertSign coherence, extension criticality (basicConstraints, nameConstraints, policyConstraints and inhibitAnyPolicy must be critical, and keyUsage should be), nameConstraints CA-scope, unknown critical extensions, empty-subject SAN, SKI and AKI presence including the end-entity subjectKeyIdentifier, SAN required and CN-in-SAN, dNSName syntax, serverAuth EKU, weak keys, the post-quantum key-usage rules binding a certificate's keyUsage bits to its subject key type (ML-KEM under RFC 9935 §5, ML-DSA under RFC 9881 §5, and SLH-DSA under RFC 9909 §6 across both its pure and prehash identifiers) together with the ML-KEM encapsulation-key encoding and size, and the §4.2.1.4 certificate-policy user-notice rules (a VisibleString or BMPString explicitText, a notice past 200 characters, an empty notice, control characters, and a non-NFC UTF8String notice, each at the strength the clause states). Alone among these entries the data path never throws: hostile bytes return a `fatal` `lint/unparseable` finding carrying the strict parser's code, so a whole directory lints without a try/catch, and only config-time misuse throws a typed `LintError` — `certificate`, `crl` (the RFC 5280 §5 revocation-list profile: nextUpdate presence, update ordering, cRLNumber presence and its 20-octet ceiling, authorityKeyIdentifier presence, the criticality each profiled CRL and entry extension must carry, freshestCRL in a delta CRL, and unrecognized critical extensions), `rules`, `profiles` |
+| `pki.lint` | Certificate linting, the zlint or pkilint of JavaScript. `certificate(pem \| der \| parsed, opts)` walks a parsed certificate and emits graded advisory findings, each with a stable id, a severity (`fatal`, `error`, `warn`, `notice`), a source, a spec-clause citation, and a message, against the RFC 5280 profile, the post-quantum certificate profiles, and a representative CA/Browser Forum TLS BR subset: serial sign and size, validity ordering and the SC081v3 reducing validity schedule, keyCertSign coherence, extension criticality (basicConstraints, nameConstraints, policyConstraints and inhibitAnyPolicy must be critical, and keyUsage should be), nameConstraints CA-scope, unknown critical extensions, empty-subject SAN, SKI and AKI presence including the end-entity subjectKeyIdentifier, the six extensions a conforming CA must mark non-critical (reported by clause rather than as unrecognized), SAN required and CN-in-SAN, dNSName syntax, serverAuth EKU, weak keys, the post-quantum key-usage rules binding a certificate's keyUsage bits to its subject key type (ML-KEM under RFC 9935 §5, ML-DSA under RFC 9881 §5, and SLH-DSA under RFC 9909 §6 across both its pure and prehash identifiers) together with the ML-KEM encapsulation-key encoding and size, and the §4.2.1.4 certificate-policy user-notice rules (a VisibleString or BMPString explicitText, a notice past 200 characters, an empty notice, control characters, and a non-NFC UTF8String notice, each at the strength the clause states). Alone among these entries the data path never throws: hostile bytes return a `fatal` `lint/unparseable` finding carrying the strict parser's code, so a whole directory lints without a try/catch, and only config-time misuse throws a typed `LintError` — `certificate`, `crl` (the RFC 5280 §5 revocation-list profile: nextUpdate presence, update ordering, cRLNumber presence and its 20-octet ceiling, authorityKeyIdentifier presence, the criticality each profiled CRL and entry extension must carry, freshestCRL in a delta CRL, and unrecognized critical extensions), `ocsp` (the RFC 6960 response profile: an empty signature, each SingleResponse's update ordering and its relation to producedAt, an empty `certs` field, the extended revoked definition and the fixed shape of a revoked answer for a non-issued certificate, the list each extension belongs in, the criticality and value syntax of the CRL entry extensions a SingleResponse may carry, unrecognized critical extensions, the reasons unspecified and removeFromCRL, and two answers for one CertID; the RFC 5019 lightweight rows run on request), `rules`, `profiles` |
 | `pki.C` / `pki.constants` | Version-stable constants: the functional scale helpers `C.TIME.*` and `C.BYTES.*`, the codec `LIMITS`, and `version` |
 | `pki.errors` | The `PkiError` taxonomy — `defineClass` plus `ConstantsError`, `Asn1Error`, `OidError`, `PemError`, `CertificateError`, `CrlError`, `CsrError`, `Pkcs8Error`, `CmsError`, `OcspError`, `TspError`, `AttrCertError`, `CrmfError`, `Pkcs12Error`, `CmpError`, `PathError`, `CtError`, `JoseError`, `AcmeError`, `WebauthnError`, and `LintError`, each carrying a stable `code` in `domain/reason` form |
-| `pki` CLI | `pki version`, `pki oid <dotted\|name>`, `pki parse <cert>`, `pki inspect <cert>`, `pki lint <cert>`, `pki convert <file> --to der\|pem`, `pki verify <cert>... --anchor <cert>`, `pki sign <file> --cert <c> --key <k>` |
+| `pki` CLI | `pki version`, `pki oid <dotted\|name>`, `pki parse <cert>`, `pki inspect <cert>`, `pki lint <cert\|crl\|ocsp-response>`, `pki convert <file> --to der\|pem`, `pki verify <cert>... --anchor <cert>`, `pki sign <file> --cert <c> --key <k>` |
 
 ### CLI
 
@@ -267,6 +267,8 @@ pki parse cert.pem                       # structured JSON summary of a certific
 pki inspect cert.pem                     # openssl x509 -text style report (pki.inspect)
 pki lint cert.pem                        # graded conformance findings; exit 1 on an error
 pki lint cert.pem --json --profile cabf-tls
+pki lint list.crl                        # detects a CRL or an OCSP response and runs its profile
+pki lint status.ors --profile rfc5019    # the RFC 5019 lightweight rows for an OCSP response
 pki convert cert.pem --to der > cert.der # transcode between PEM and DER (round-trips)
 pki verify leaf.pem --anchor root.pem --time 2026-01-01T00:00:00Z   # RFC 5280 path validation
 pki sign msg.txt --cert signer.pem --key signer-key.pem --out msg.p7s   # CMS SignedData (pki.cms.sign)

package/bin/pki.js

@@ -9,7 +9,7 @@
  *   pki oid <dotted|name>                resolve an OID <-> name
  *   pki parse <cert>                      parse an X.509 certificate to JSON
  *   pki inspect <cert>                    render a certificate as text (openssl x509 -text style)
- *   pki lint <cert> [--profile P]         lint a certificate; exit non-zero on an error finding
+ *   pki lint <file> [--profile P]         lint a certificate, CRL or OCSP response; exit non-zero on an error finding
  *              [--severity S] [--json]
  *   pki convert <file> --to der|pem       transcode a DER/PEM file between the two encodings
  *              [--label LABEL]
@@ -135,15 +135,31 @@ function cmdInspect(file) {
 
 function pad(s, n) { while (s.length < n) s += " "; return s; }
 
-// pki lint <cert> -- lint against pki.lint's profiles. Prints one line per finding and
-// exits non-zero when any error/fatal finding is present (0 when the worst is advisory).
+// The lint verb for each structure `pki lint` detects. A file holding anything else (a request, a
+// CMS message, a key) has no lint profile and is refused by the name the detector gives it.
+var LINT_VERB_FOR = { "x509": "certificate", "crl": "crl", "ocsp-response": "ocsp" };
+
+// pki lint <file> -- detect whether the file holds a certificate, a CRL or an OCSP response and
+// lint it against that structure's profiles. Prints one line per finding and exits non-zero
+// when any error/fatal finding is present (0 when the worst is advisory).
 function cmdLint(args) {
   var file = args._[0];
-  if (!file) fail("usage: pki lint <cert> [--profile <name>] [--severity <floor>] [--json]");
+  if (!file) fail("usage: pki lint <cert|crl|ocsp-response> [--profile <name>] [--severity <floor>] [--json]");
+  var input = readForLib(file);
+  // Bytes no detector recognizes (garbage, or a structure outside the detector's set) fall
+  // through to the certificate verb, whose never-throw data path reports them as a fatal
+  // lint/unparseable finding; a structure the detector DOES name but no profile covers is a
+  // config-time refusal naming it, so a request is not silently linted as a certificate.
+  var verb = "certificate", format;
+  try { format = pki.schema.detectFormat(input); } catch (_e) { format = null; }
+  if (format !== null) {
+    verb = LINT_VERB_FOR[format];
+    if (verb === undefined) return fail(file + ": holds a " + format + " structure, and pki lint covers a certificate, CRL, or OCSP response");
+  }
   var report;
   // Config-time misuse (unknown profile / bad severity) throws a typed LintError; the data
   // path never throws (malformed bytes become a fatal lint/unparseable finding).
-  try { report = pki.lint.certificate(readForLib(file), { profile: args.profile, severity: args.severity }); }
+  try { report = pki.lint[verb](input, { profile: args.profile, severity: args.severity }); }
   catch (e) { return fail(e.code + ": " + e.message); }
   if (args.json) {
     process.stdout.write(JSON.stringify(report, null, 2) + "\n");

package/lib/lint.js

@@ -5,15 +5,16 @@
  * @module pki.lint
  * @nav        Tooling
  * @title      Lint
- * @fullname   Certificate and revocation-list linting against RFC 5280 and CA/Browser Forum
- *             requirements
+ * @fullname   Certificate, revocation-list and OCSP-response linting against RFC 5280, RFC 6960
+ *             and CA/Browser Forum requirements
  * @intro The LINTING engine, the zlint / pkilint of JavaScript. It walks an ALREADY-PARSED
- *   certificate or certificate revocation list (from `pki.schema.x509.parse` or
- *   `pki.schema.crl.parse`, whose extension values it decodes with the shared RFC 5280
- *   decoders) and emits graded, advisory FINDINGS: each with a stable id, a severity
- *   (`fatal` > `error` > `warn` > `notice` > `pass`), a source, a spec-clause citation, and
- *   a human message. It ships the RFC 5280 certificate profile, the RFC 5280 section 5
- *   revocation-list profile, the post-quantum certificate profiles for ML-KEM, ML-DSA and
+ *   certificate, certificate revocation list or OCSP response (from `pki.schema.x509.parse`,
+ *   `pki.schema.crl.parse` or `pki.schema.ocsp.parseResponse`, whose extension values it
+ *   decodes with the shared RFC 5280 decoders) and emits graded, advisory FINDINGS: each with
+ *   a stable id, a severity (`fatal` > `error` > `warn` > `notice` > `pass`), a source, a
+ *   spec-clause citation, and a human message. It ships the RFC 5280 certificate profile, the
+ *   RFC 5280 section 5 revocation-list profile, the RFC 6960 OCSP response profile with the
+ *   RFC 5019 lightweight rows, the post-quantum certificate profiles for ML-KEM, ML-DSA and
  *   SLH-DSA, and a representative CA/Browser Forum TLS Baseline Requirements subset.
  *
  *   Unlike every other toolkit entry, the lint data path never throws. A linter surveys a
@@ -23,8 +24,8 @@
  *   unknown profile, an out-of-range severity threshold, or a wrong-type input), which
  *   raises a typed `LintError`. This deliberate inversion of the toolkit's fail-closed-throw
  *   posture is what lets an operator lint a whole directory without a try/catch per file.
- * @spec RFC 5280, RFC 9881, RFC 9909, RFC 9935, CA/Browser Forum TLS Baseline Requirements
- * @card Lint a certificate or CRL against RFC 5280 + CABF TLS BR, in pure JS.
+ * @spec RFC 5280, RFC 6960, RFC 5019, RFC 9654, RFC 9881, RFC 9909, RFC 9935, CA/Browser Forum TLS Baseline Requirements
+ * @card Lint a certificate, CRL or OCSP response against RFC 5280, RFC 6960 + CABF TLS BR, in pure JS.
  */
 
 var frameworkError = require("./framework-error");
@@ -33,6 +34,7 @@ var guard = require("./guard-all");
 var oid = require("./oid");
 var x509 = require("./schema-x509");
 var crlSchema = require("./schema-crl");
+var ocspSchema = require("./schema-ocsp");
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
 var path = require("./path-validate");
@@ -193,9 +195,18 @@ function _subjectCNs(cert) {
   return out;
 }
 
+/** @internal The criticality RFC 5280 fixes for a certificate extension, read from the shared table
+ * the certificate signer refuses to write against. The profile has its own row for each extension
+ * the table holds CRITICAL (basicConstraints, nameConstraints, policyConstraints, inhibitAnyPolicy),
+ * so only the NON-critical direction is graded through this table, under one id, the way the CRL
+ * profile grades its criticality rows. */
+var CERT_FIXED_CRITICALITY = pkix.certFixedCriticality(oid);
 var _CRITICAL_LEGIT = Object.create(null);
 _CRITICAL_LEGIT[oid.byName("precertificatePoison")] = true;
+/** @internal An extension whose criticality the profile fixes is one it recognizes: marked against
+ * the table it is a criticality fault with its own row, never an unrecognized extension. */
 function _isUnknownExtension(extOid) {
+  if (CERT_FIXED_CRITICALITY[extOid] !== undefined) return false;
   if (path.PROCESSED_EXTENSIONS[extOid] !== true) return _CRITICAL_LEGIT[extOid] !== true;
   return path.TARGET_UNPROCESSED_IF_CRITICAL[extOid] === true;
 }
@@ -261,6 +272,29 @@ function _criticalityRule(name, id, severity, citation, message) {
 }
 
 var RFC5280_RULES = [
+  {
+    id: "lint/rfc5280/signature-empty", severity: "error", source: "rfc5280", citation: "RFC 5280 4.1.1.3",
+    /** @internal The strict parser admits an empty BIT STRING, since one is well-formed DER; a
+     * signatureValue that contains no signature is not the field section 4.1.1.3 defines. */
+    message: "the signatureValue contains no signature",
+    check: function (cert) { return cert.signatureValue.bytes.length === 0 ? true : null; },
+  },
+  {
+    id: "lint/rfc5280/extension-criticality", severity: "error", source: "rfc5280", citation: "RFC 5280 4.2.1.1 / 4.2.1.2 / 4.2.1.8 / 4.2.1.15 / 4.2.2.1 / 4.2.2.2",
+    message: "an extension a conforming CA must mark non-critical is marked critical",
+    /** @internal Keyed by the extension's OID throughout. The display name the parser attaches can
+     * be re-pointed through the registry, so a lookup by name would answer for a different
+     * extension, or for none. */
+    check: function (cert) {
+      var rows = [];
+      (cert.extensions || []).forEach(function (e) {
+        var fixed = CERT_FIXED_CRITICALITY[e.oid];
+        if (fixed === undefined || fixed.critical !== false || e.critical !== true) return;
+        rows.push({ context: { extension: e.name || e.oid, oid: e.oid, required: "non-critical", was: "critical", scope: "extensions", citation: fixed.citation } });
+      });
+      return rows.length ? rows : null;
+    },
+  },
   {
     id: "lint/rfc5280/serial-not-positive", severity: "error", source: "rfc5280", citation: "RFC 5280 4.1.2.2",
     message: "the certificate serialNumber must be a positive integer",
@@ -832,6 +866,11 @@ function _criticalityRows(list, table, what) {
  * and a present-but-empty revokedCertificates (sec. 5.1.2.6, `crl/bad-revoked-certificates`). Each
  * reaches a caller as the engine's fatal lint/unparseable carrying that code. */
 var RFC5280_CRL_RULES = [
+  {
+    id: "lint/rfc5280-crl/signature-empty", severity: "error", source: "rfc5280-crl", citation: "RFC 5280 5.1.1.3",
+    message: "the signatureValue contains no signature",
+    check: function (crl) { return crl.signatureValue.bytes.length === 0 ? true : null; },
+  },
   {
     id: "lint/rfc5280-crl/next-update-missing", severity: "error", source: "rfc5280-crl", citation: "RFC 5280 5.1.2.5",
     message: "a conforming CRL issuer includes the nextUpdate field in every CRL",
@@ -1281,6 +1320,398 @@ var RFC5280_CRL_RULES = [
 var CRL_PROFILES = Object.assign(Object.create(null), { "rfc5280-crl": RFC5280_CRL_RULES });
 var ALL_CRL_RULES = RFC5280_CRL_RULES;
 
+
+/** @internal The extensions RFC 6960 and RFC 9654 place on a response, by the list each belongs
+ * in. The nonce and the extended revoked definition are response extensions; the archive cutoff and
+ * the CRL references are single extensions, and sec. 4.4.5 carries every RFC 5280 sec. 5.3 CRL
+ * entry extension into a SingleResponse as well. Three more are defined for REQUESTS only. */
+var OCSP_RESPONSE_KNOWN = Object.create(null);
+["ocspNonce", "ocspExtendedRevoke"].forEach(function (n) { OCSP_RESPONSE_KNOWN[oid.byName(n)] = true; });
+var OCSP_SINGLE_KNOWN = Object.create(null);
+["ocspArchiveCutoff", "ocspCrl", "reasonCode", "invalidityDate", "certificateIssuer"]
+  .forEach(function (n) { OCSP_SINGLE_KNOWN[oid.byName(n)] = true; });
+var OCSP_REQUEST_ONLY = Object.create(null);
+[["ocspResponse", "RFC 6960 4.4.3"], ["ocspServiceLocator", "RFC 6960 4.4.6"], ["ocspPrefSigAlgs", "RFC 6960 4.4.7"]]
+  .forEach(function (r) { OCSP_REQUEST_ONLY[oid.byName(r[0])] = r[1]; });
+/** @internal Only the criticality a clause states. Sec. 4.4.8 forbids a critical extended revoked
+ * definition; sec. 4.4.5 carries the RFC 5280 sec. 5.3 rules for the three entry extensions. RFC
+ * 6960 states nothing about the criticality of the nonce, the archive cutoff or the CRL references,
+ * so they are absent here. */
+var OCSP_RESPONSE_CRITICALITY = Object.create(null);
+OCSP_RESPONSE_CRITICALITY[oid.byName("ocspExtendedRevoke")] = false;
+var OCSP_SINGLE_CRITICALITY = CRL_ENTRY_CRITICALITY;
+
+var OID_OCSP_NONCE = oid.byName("ocspNonce");
+var OID_OCSP_EXTENDED_REVOKE = oid.byName("ocspExtendedRevoke");
+var OID_OCSP_ARCHIVE_CUTOFF = oid.byName("ocspArchiveCutoff");
+var OID_OCSP_CRL = oid.byName("ocspCrl");
+var OID_REASON_CODE = oid.byName("reasonCode");
+
+/** @internal How each single extension the OCSP parser leaves opaque is read: reasonCode and
+ * invalidityDate through the CRL parser's own entry-extension reader, so the linter and the CRL
+ * parser cannot disagree about what a well-formed one is, and certificateIssuer through the shared
+ * GeneralNames walk the CRL rows use. The parser decodes the nonce, the archive cutoff and the CRL
+ * references itself and refuses a malformed one, so an entry for any of those would be dead. */
+var OCSP_SINGLE_VALUE_READER = Object.create(null);
+OCSP_SINGLE_VALUE_READER[OID_REASON_CODE] = function (bytes) {
+  crlSchema.decodeExtension({ oid: OID_REASON_CODE, name: "reasonCode", critical: false, value: bytes });
+};
+OCSP_SINGLE_VALUE_READER[oid.byName("invalidityDate")] = function (bytes) {
+  crlSchema.decodeExtension({ oid: oid.byName("invalidityDate"), name: "invalidityDate", critical: false, value: bytes });
+};
+OCSP_SINGLE_VALUE_READER[oid.byName("certificateIssuer")] = CRL_ENTRY_VALUE_READER[oid.byName("certificateIssuer")];
+var OCSP_RESPONSE_VALUE_READER = Object.create(null);
+/** @internal Read through the codec's NULL reader, which refuses content octets as well as a wrong
+ * tag; the decoder alone frames `05 01 00` as a NULL carrying one octet. */
+OCSP_RESPONSE_VALUE_READER[OID_OCSP_EXTENDED_REVOKE] = function (bytes) {
+  asn1.read.nullValue(asn1.decode(bytes));
+};
+
+function _ocspBasic(resp) { return resp.basicResponse; }
+/** @internal The parser refuses an empty `responses`, so the list is never empty here. */
+function _ocspResponses(resp) { return _ocspBasic(resp).responses; }
+function _ocspResponseExts(resp) { return _ocspBasic(resp).responseExtensions || []; }
+function _ocspSingleExts(sr) { return sr.singleExtensions || []; }
+function _extIn(list, dotted) {
+  for (var i = 0; i < list.length; i++) { if (list[i].oid === dotted) return list[i]; }
+  return null;
+}
+/** @internal The revocation reason a single extension carries, read with the CRL parser's reader,
+ * or null when the extension is absent or does not read (the value-syntax row reports that). */
+function _singleReasonCode(sr) {
+  var e = _extIn(_ocspSingleExts(sr), OID_REASON_CODE);
+  if (!e || !Buffer.isBuffer(e.value)) return null;
+  // allow:swallow-unverified a value the CRL reader refuses carries no reason; the value-syntax row reports it
+  try { return crlSchema.decodeExtension(e).value; }
+  catch (_e) { return null; }
+}
+/** @internal RFC 6960 sec. 2.2 gives a "revoked" answer for a non-issued certificate a fixed shape:
+ * the reason certificateHold and the revocation time January 1, 1970. That shape is how a response
+ * says it is answering for a certificate that was never issued, and the rows that hold such an
+ * answer to the rest of sec. 2.2 recognize it by exactly those two values. */
+function _isNonIssuedShape(sr) {
+  var st = sr.certStatus;
+  return !!st && st.type === "revoked" && st.revocationReason === "certificateHold" &&
+    guard.time.isDate(st.revocationTime) && guard.time.instantOf(st.revocationTime) === 0;
+}
+/** @internal The rows in one list that carry a per-response index, so a finding names which
+ * SingleResponse it is about the way the CRL entry rows name their entry. */
+function _perResponse(resp, fn) {
+  var rows = [];
+  _ocspResponses(resp).forEach(function (sr, i) {
+    var out = fn(sr, i);
+    if (out == null) return;
+    (Array.isArray(out) ? out : [out]).forEach(function (row) { row.context.response = i; rows.push(row); });
+  });
+  return rows.length ? rows : null;
+}
+/** @internal A CertID as one lookup key, every field included, so two SingleResponses name the same
+ * certificate under the same hash exactly when their keys match. Keyed rather than compared
+ * pairwise: a response lists as many SingleResponses as its author chooses, and this verb exists to
+ * survey ones that arrived from elsewhere, so a pairwise scan would be quadratic in that choice. */
+function _certIdKey(c) {
+  return c.hashAlgorithm.algorithm + "|" + c.issuerNameHash.toString("hex") + "|" + c.issuerKeyHash.toString("hex") + "|" + c.serialNumberHex;
+}
+function _statusKey(st) {
+  return st.type + (st.type === "revoked" ? ":" + guard.time.instantOf(st.revocationTime) + ":" + (st.revocationReason || "") : "");
+}
+/** @internal The placement rows share one shape: an extension found in the list the specification
+ * does not define it for. `where` names the list it was found in; `context.placed` says where the
+ * specification puts it. */
+function _placementRow(name, placed, where) {
+  return { context: { extension: name, placed: placed, was: where } };
+}
+
+/** @internal Four sec. 4.2 rules have no row because the strict parser refuses them first and a rule
+ * for them would be dead: a version other than v1 (sec. 4.2.2.3, `ocsp/bad-version`), an undefined
+ * CRLReason value (`ocsp/bad-revocation-reason`), an empty extension list (`ocsp/bad-extensions`)
+ * and a repeated extension (`ocsp/duplicate-extension`); so are an empty `responses`
+ * (`ocsp/bad-responses`), a nonce outside 1..128 octets (`ocsp/bad-nonce`), a malformed archive
+ * cutoff or CrlID, a responseStatus that disagrees with responseBytes, and every time-format rule of
+ * RFC 5019 sec. 2.2.4, which the DER codec enforces. Each reaches a caller as the engine's fatal
+ * lint/unparseable carrying that code. */
+var RFC6960_OCSP_RULES = [
+  {
+    id: "lint/rfc6960/signature-empty", severity: "error", source: "rfc6960", citation: "RFC 6960 2.2",
+    message: "a definitive response shall be digitally signed; the signature BIT STRING is empty",
+    check: function (resp) { return _ocspBasic(resp).signature.length === 0 ? true : null; },
+  },
+  {
+    id: "lint/rfc6960/update-times-inverted", severity: "error", source: "rfc6960", citation: "RFC 6960 2.4 / 4.2.2.1",
+    /** @internal Sec. 4.2.2.1 defines the two as a validity interval and says it corresponds to the
+     * CRL's, whose inversion the CRL profile grades the same way; an interval whose end precedes
+     * its start is a fault of definition, like an extension on the wrong list, rather than a
+     * reading, and pki.ocsp.sign refuses to write one. */
+    message: "a SingleResponse's thisUpdate must not follow its nextUpdate",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        // allow:nan-date-comparison-unguarded -- both are codec-parsed OCSP times (asn1 readTime rejects a NaN instant).
+        if (sr.nextUpdate === null) return null;
+        return guard.time.instantOf(sr.thisUpdate) > guard.time.instantOf(sr.nextUpdate) ? { context: {} } : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/produced-before-this-update", severity: "notice", source: "rfc6960", citation: "RFC 6960 2.4 / 2.5",
+    /** @internal producedAt is the time the responder signed, thisUpdate the most recent time the
+     * status was known to be correct; a response signed before that time certifies status it did
+     * not yet know. No clause forbids it, so this is advisory. */
+    message: "producedAt is earlier than a SingleResponse's thisUpdate, so the response was signed before the status it certifies was known",
+    check: function (resp) {
+      var produced = _ocspBasic(resp).producedAt;
+      return _perResponse(resp, function (sr) {
+        // allow:nan-date-comparison-unguarded -- both are codec-parsed OCSP times (asn1 readTime rejects a NaN instant).
+        return guard.time.instantOf(produced) < guard.time.instantOf(sr.thisUpdate) ? { context: {} } : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/certs-present-but-empty", severity: "warn", source: "rfc6960", citation: "RFC 6960 4.2.1",
+    message: "certs should be absent when no certificates are included",
+    check: function (resp) { var bs = _ocspBasic(resp); return bs.certsPresent === true && bs.certs.length === 0 ? true : null; },
+  },
+  {
+    id: "lint/rfc6960/response-extension-criticality", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.8",
+    message: "a response extension is marked with a criticality the profile does not allow",
+    check: function (resp) {
+      var rows = _criticalityRows(_ocspResponseExts(resp), OCSP_RESPONSE_CRITICALITY, "responseExtensions");
+      return rows.length ? rows : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/single-extension-criticality", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.5 / RFC 5280 5.3.1 / 5.3.2 / 5.3.3",
+    message: "a single extension is marked with a criticality the profile does not allow",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) { return _criticalityRows(_ocspSingleExts(sr), OCSP_SINGLE_CRITICALITY, "singleExtensions"); });
+    },
+  },
+  {
+    id: "lint/rfc6960/extended-revoke-value-not-null", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.8",
+    message: "the value of the extended revoked definition extension shall be NULL",
+    check: function (resp) {
+      var e = _extIn(_ocspResponseExts(resp), OID_OCSP_EXTENDED_REVOKE);
+      return e && _valueSyntaxFault(e, OCSP_RESPONSE_KNOWN, OCSP_RESPONSE_VALUE_READER) !== null ? true : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/extended-revoke-in-single-extensions", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.8",
+    message: "the extended revoked definition extension must be placed in responseExtensions and must not appear in singleExtensions",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        return _extIn(_ocspSingleExts(sr), OID_OCSP_EXTENDED_REVOKE) ? _placementRow("ocspExtendedRevoke", "responseExtensions", "singleExtensions") : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/non-issued-without-extended-revoke", severity: "error", source: "rfc6960", citation: "RFC 6960 2.2",
+    message: "a revoked answer for a non-issued certificate (certificateHold at January 1, 1970) must be accompanied by the extended revoked definition response extension",
+    check: function (resp) {
+      if (_extIn(_ocspResponseExts(resp), OID_OCSP_EXTENDED_REVOKE)) return null;
+      return _perResponse(resp, function (sr) { return _isNonIssuedShape(sr) ? { context: {} } : null; });
+    },
+  },
+  {
+    id: "lint/rfc6960/non-issued-with-crl-extensions", severity: "error", source: "rfc6960", citation: "RFC 6960 2.2",
+    message: "a revoked answer for a non-issued certificate must not include a CRL references extension or any CRL entry extension",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        if (!_isNonIssuedShape(sr)) return null;
+        var rows = [];
+        _ocspSingleExts(sr).forEach(function (e) {
+          if (e.oid === OID_OCSP_CRL || CRL_ENTRY_CRITICALITY[e.oid] !== undefined) rows.push({ context: { extension: e.name } });
+        });
+        return rows.length ? rows : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/archive-cutoff-in-response-extensions", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.4",
+    message: "an archive cutoff shall be provided as a singleExtensions extension",
+    check: function (resp) {
+      return _extIn(_ocspResponseExts(resp), OID_OCSP_ARCHIVE_CUTOFF) ? _placementRow("ocspArchiveCutoff", "singleExtensions", "responseExtensions") : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/crl-references-in-response-extensions", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.2",
+    message: "the CRL references extension is specified as a singleExtensions extension",
+    check: function (resp) {
+      return _extIn(_ocspResponseExts(resp), OID_OCSP_CRL) ? _placementRow("ocspCrl", "singleExtensions", "responseExtensions") : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/nonce-in-single-extensions", severity: "error", source: "rfc6960", citation: "RFC 9654 2.1",
+    message: "in a response the nonce is included as one of the responseExtensions",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        return _extIn(_ocspSingleExts(sr), OID_OCSP_NONCE) ? _placementRow("ocspNonce", "responseExtensions", "singleExtensions") : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/request-extension-in-response", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.3 / 4.4.6 / 4.4.7",
+    message: "an extension defined for OCSP requests only is carried on a response",
+    check: function (resp) {
+      var rows = [];
+      _ocspResponseExts(resp).forEach(function (e) {
+        if (OCSP_REQUEST_ONLY[e.oid] !== undefined) rows.push({ context: { extension: e.name, defined: OCSP_REQUEST_ONLY[e.oid], was: "responseExtensions" } });
+      });
+      var per = _perResponse(resp, function (sr) {
+        var out = [];
+        _ocspSingleExts(sr).forEach(function (e) {
+          if (OCSP_REQUEST_ONLY[e.oid] !== undefined) out.push({ context: { extension: e.name, defined: OCSP_REQUEST_ONLY[e.oid], was: "singleExtensions" } });
+        });
+        return out.length ? out : null;
+      });
+      if (per) per.forEach(function (row) { rows.push(row); });
+      return rows.length ? rows : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/archive-cutoff-after-produced-at", severity: "notice", source: "rfc6960", citation: "RFC 6960 4.4.4",
+    /** @internal The archive cutoff is defined as producedAt minus the responder's retention
+     * interval, so a cutoff after producedAt states a negative interval. Stated by definition
+     * rather than as a requirement, so advisory. */
+    message: "an archive cutoff later than producedAt implies a negative retention interval",
+    check: function (resp) {
+      var produced = _ocspBasic(resp).producedAt;
+      return _perResponse(resp, function (sr) {
+        var e = _extIn(_ocspSingleExts(sr), OID_OCSP_ARCHIVE_CUTOFF);
+        // allow:nan-date-comparison-unguarded -- both are codec-parsed OCSP times (the parser refuses an archive cutoff that is not a GeneralizedTime).
+        if (!e) return null;
+        return guard.time.instantOf(e.archiveCutoff) > guard.time.instantOf(produced) ? { context: {} } : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/extension-value-syntax", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.5 / 4.4.8",
+    message: "a recognized extension's value does not decode as the structure its identifier names",
+    check: function (resp) {
+      var rows = [];
+      _ocspResponseExts(resp).forEach(function (e) {
+        var why = _valueSyntaxFault(e, OCSP_RESPONSE_KNOWN, OCSP_RESPONSE_VALUE_READER);
+        if (why !== null) rows.push({ context: { extension: e.name, scope: "responseExtensions", problem: why } });
+      });
+      var per = _perResponse(resp, function (sr) {
+        var out = [];
+        _ocspSingleExts(sr).forEach(function (e) {
+          var why = _valueSyntaxFault(e, OCSP_SINGLE_KNOWN, OCSP_SINGLE_VALUE_READER);
+          if (why !== null) out.push({ context: { extension: e.name, scope: "singleExtensions", problem: why } });
+        });
+        return out.length ? out : null;
+      });
+      if (per) per.forEach(function (row) { rows.push(row); });
+      return rows.length ? rows : null;
+    },
+  },
+  {
+    id: "lint/rfc6960/unknown-critical-extension", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4 / RFC 5019 2.2.1",
+    /** @internal RFC 6960 adopts the RFC 5280 extension model, under which a consumer that cannot
+     * process a critical extension must not use the structure, and RFC 5019 lets a client ignore
+     * only an unrecognized NON-critical response extension. The recognized set is the one this
+     * profile reads, per list. */
+    message: "a critical extension the profile does not recognize is present",
+    check: function (resp) {
+      var rows = [];
+      _ocspResponseExts(resp).forEach(function (e) {
+        if (e.critical === true && OCSP_RESPONSE_KNOWN[e.oid] === undefined) rows.push({ context: { extension: e.name || e.oid, scope: "responseExtensions" } });
+      });
+      var per = _perResponse(resp, function (sr) {
+        var out = [];
+        _ocspSingleExts(sr).forEach(function (e) {
+          if (e.critical === true && OCSP_SINGLE_KNOWN[e.oid] === undefined) out.push({ context: { extension: e.name || e.oid, scope: "singleExtensions" } });
+        });
+        return out.length ? out : null;
+      });
+      if (per) per.forEach(function (row) { rows.push(row); });
+      return rows.length ? rows : null;
+    },
+  },
+  /** @internal The two reason rules each have two carriers graded apart. The reasonCode single
+   * extension IS the RFC 5280 sec. 5.3.1 extension, carried into a SingleResponse by sec. 4.4.5, so
+   * its rows grade at that clause's strength. RevokedInfo's own revocationReason is a separate field
+   * of the same CRLReason type, and the clause is applied to it by reading, so its rows are advisory. */
+  {
+    id: "lint/rfc6960/reason-code-unspecified", severity: "warn", source: "rfc6960", citation: "RFC 6960 4.4.5 / RFC 5280 5.3.1",
+    message: "a reasonCode single extension of unspecified(0) should be absent instead",
+    check: function (resp) { return _perResponse(resp, function (sr) { return _singleReasonCode(sr) === 0 ? { context: {} } : null; }); },
+  },
+  {
+    id: "lint/rfc6960/remove-from-crl-reason", severity: "error", source: "rfc6960", citation: "RFC 6960 4.4.5 / RFC 5280 5.3.1",
+    message: "a reasonCode of removeFromCRL may only appear in a delta CRL; a status response is not one",
+    check: function (resp) { return _perResponse(resp, function (sr) { return _singleReasonCode(sr) === 8 ? { context: {} } : null; }); },
+  },
+  {
+    id: "lint/rfc6960/revocation-reason-unspecified", severity: "notice", source: "rfc6960", citation: "RFC 6960 4.2.1 / RFC 5280 5.3.1",
+    message: "a revocationReason of unspecified(0) states no reason; the reasonCode extension it mirrors should be absent instead",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        return sr.certStatus.type === "revoked" && sr.certStatus.revocationReason === "unspecified" ? { context: {} } : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/revocation-reason-remove-from-crl", severity: "notice", source: "rfc6960", citation: "RFC 6960 4.2.1 / RFC 5280 5.3.1",
+    message: "a revocationReason of removeFromCRL names a delta-CRL action, which a status response cannot state",
+    check: function (resp) {
+      return _perResponse(resp, function (sr) {
+        return sr.certStatus.type === "revoked" && sr.certStatus.revocationReason === "removeFromCRL" ? { context: {} } : null;
+      });
+    },
+  },
+  {
+    id: "lint/rfc6960/duplicate-cert-id", severity: "notice", source: "rfc6960", citation: "RFC 6960 4.2.2.3",
+    /** @internal A response carries a SingleResponse per certificate. Two for the same CertID
+     * answer one certificate twice, and when the two statuses differ a relying party cannot tell
+     * which governs; the context says which case it is. No clause forbids the repeat, so advisory. */
+    message: "two SingleResponses answer for the same CertID",
+    check: function (resp) {
+      var rows = [], first = Object.create(null);
+      _ocspResponses(resp).forEach(function (sr, i) {
+        var key = _certIdKey(sr.certID), seen = first[key];
+        if (seen === undefined) { first[key] = { index: i, status: _statusKey(sr.certStatus) }; return; }
+        rows.push({ context: { response: i, first: seen.index, conflicting: seen.status !== _statusKey(sr.certStatus) } });
+      });
+      return rows.length ? rows : null;
+    },
+  },
+];
+
+/** @internal Nothing in a response says which profile its responder follows, so the RFC 5019 rows
+ * run only when that profile is selected and count as not applicable otherwise. */
+function _isLightweight(resp, ctx) { return ctx.profile === "rfc5019"; }
+
+var RFC5019_OCSP_RULES = [
+  {
+    id: "lint/rfc5019/next-update-missing", severity: "error", source: "rfc5019", citation: "RFC 5019 2.2.4",
+    message: "a lightweight-profile responder must always include nextUpdate",
+    appliesTo: _isLightweight,
+    check: function (resp) { return _perResponse(resp, function (sr) { return sr.nextUpdate == null ? { context: {} } : null; }); },
+  },
+  {
+    id: "lint/rfc5019/multiple-single-responses", severity: "warn", source: "rfc5019", citation: "RFC 5019 2.2.1",
+    message: "a lightweight-profile response should include only one SingleResponse",
+    appliesTo: _isLightweight,
+    check: function (resp) { var n = _ocspResponses(resp).length; return n > 1 ? { context: { responses: n } } : null; },
+  },
+  {
+    id: "lint/rfc5019/response-extensions-present", severity: "warn", source: "rfc5019", citation: "RFC 5019 2.2.1",
+    message: "a lightweight-profile responder should not include responseExtensions",
+    appliesTo: _isLightweight,
+    check: function (resp) { return _ocspBasic(resp).responseExtensions ? true : null; },
+  },
+  {
+    id: "lint/rfc5019/responder-id-by-name", severity: "notice", source: "rfc5019", citation: "RFC 5019 2.2.2",
+    /** @internal A SHOULD conditioned on bandwidth being at issue, which the response cannot show,
+     * so it grades as advisory rather than as the warning an unconditional SHOULD would draw. */
+    message: "a lightweight-profile responder should use the byKey ResponderID where reducing bandwidth matters",
+    appliesTo: _isLightweight,
+    check: function (resp) { var rid = _ocspBasic(resp).responderID; return rid && rid.byName !== undefined ? true : null; },
+  },
+];
+
+var OCSP_PROFILES = Object.assign(Object.create(null), { "rfc6960": RFC6960_OCSP_RULES, "rfc5019": RFC5019_OCSP_RULES });
+var ALL_OCSP_RULES = RFC6960_OCSP_RULES.concat(RFC5019_OCSP_RULES);
+
 var PROFILES = Object.assign(Object.create(null), {
   "rfc5280": RFC5280_RULES,
   "rfc9881": RFC9881_RULES,
@@ -1294,6 +1725,7 @@ function _selectRules(profile) {
   if (profile == null || profile === "all" || profile === "default") return ALL_RULES;
   if (!PROFILES[profile]) {
     if (CRL_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a CRL profile; lint a CRL with pki.lint.crl");
+    if (OCSP_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is an OCSP profile; lint a response with pki.lint.ocsp");
     throw _cfg("lint/unknown-profile", "unknown lint profile \"" + profile + "\" (known: " + Object.keys(PROFILES).join(", ") + ")");
   }
   return PROFILES[profile];
@@ -1447,6 +1879,7 @@ function crl(input, opts) {
   if (profile == null || profile === "all" || profile === "default") rules_ = ALL_CRL_RULES;
   else if (CRL_PROFILES[profile]) rules_ = CRL_PROFILES[profile];
   else if (PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a certificate profile; lint a certificate with pki.lint.certificate");
+  else if (OCSP_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is an OCSP profile; lint a response with pki.lint.ocsp");
   else throw _cfg("lint/unknown-profile", "unknown CRL lint profile \"" + profile + "\" (known: " + Object.keys(CRL_PROFILES).join(", ") + ")");
 
   var ingested = _ingestCrl(input);
@@ -1462,6 +1895,121 @@ function crl(input, opts) {
   return report;
 }
 
+var _OCSP_OPTS = Object.assign(Object.create(null), { profile: 1, severity: 1 });
+var _OCSP_CLAIM = ["responseStatus", "basicResponse", "tbsResponseDataBytes"];
+
+/** @internal The door pki.ocsp.verify uses for a parsed response: a result the parser recorded is
+ * re-read from the source it came from, which is the DER when the parser was fed bytes and the PEM
+ * text when it was fed a string, and an object that merely carries a response's field names is
+ * refused as config-time misuse rather than linted, since its fields could describe different
+ * responses. Bytes and PEM take the fatal path below, never a throw. */
+function _ingestOcsp(input) {
+  var der;
+  if (Buffer.isBuffer(input)) der = input;
+  else if (typeof input === "string") {
+    try { der = ocspSchema.pemDecode(input); }
+    catch (e) { return { fatal: { id: "lint/unparseable", severity: "fatal", source: "engine", citation: "pki.lint", message: "input is not a decodable PEM/DER OCSP response", context: { code: e.code } } }; }
+  } else if (input !== null && typeof input === "object" && !guard.bytes.isByteSource(input)) {
+    return { response: guard.parsed.fromTrustedSource(input, "ocspResponse", _OCSP_CLAIM, function (src) {
+      if (!Buffer.isBuffer(src) && typeof src !== "string") throw _cfg("lint/bad-input", "pki.lint.ocsp input must be a parsed OCSP response, a DER Buffer, or a PEM string");
+      return ocspSchema.parseResponse(src);
+    }, _cfg, "lint/bad-input",
+    "pki.lint.ocsp input must be its DER bytes, a PEM string, or an unmodified pki.schema.ocsp.parseResponse result: the signed byte range, the signature and the fields that range encodes are separate properties of a parsed object, so a rebuilt response could have them describe different responses") };
+  } else {
+    throw _cfg("lint/bad-input", "pki.lint.ocsp input must be a parsed OCSP response, a DER Buffer, or a PEM string");
+  }
+  try { return { response: ocspSchema.parseResponse(der) }; }
+  catch (e) { return { fatal: { id: "lint/unparseable", severity: "fatal", source: "engine", citation: "RFC 6960", message: "input is not a well-formed OCSP response", context: { code: e.code } } }; }
+}
+
+/**
+ * @primitive  pki.lint.ocsp
+ * @signature  pki.lint.ocsp(pem | der | parsed, opts?) -> LintReport
+ * @since      0.7.26
+ * @status     stable
+ * @spec       RFC 6960, RFC 5019, RFC 9654
+ * @related    pki.lint.certificate, pki.lint.crl, pki.schema.ocsp.parseResponse, pki.ocsp.sign, pki.ocsp.verify
+ *
+ * Lint an OCSP response against the RFC 6960 profile, and on request against the RFC 5019
+ * lightweight profile. `input` is a PEM string (`OCSP RESPONSE`), a DER `Buffer`, or an
+ * already-parsed `pki.schema.ocsp.parseResponse` object. It returns the same `LintReport` shape
+ * `pki.lint.certificate` returns, and it never throws on the data path: bytes that are not a
+ * well-formed response produce a single `fatal` finding `lint/unparseable` carrying the strict
+ * parser's own code. A non-successful response carries no BasicOCSPResponse and draws no row.
+ *
+ * The `rfc6960` rows cover each SingleResponse's update times and their relation to producedAt,
+ * an empty `certs` field, the extended revoked definition (criticality, value and placement) and
+ * the fixed shape of a revoked answer for a non-issued certificate, the placement of the nonce,
+ * archive cutoff, CRL references and the request-only extensions, an archive cutoff later than
+ * producedAt, the criticality and value syntax of the CRL entry extensions a SingleResponse may
+ * carry, an unrecognized critical extension, the revocation reasons unspecified and removeFromCRL,
+ * and two SingleResponses answering for one CertID. The `rfc5019` rows (nextUpdate present, one
+ * SingleResponse, no responseExtensions, a byKey ResponderID) run only when that profile is
+ * selected, since nothing in a response says which profile its responder follows; in the default
+ * run they count as not applicable.
+ *
+ * Shapes the strict parser refuses never reach a rule and arrive as `lint/unparseable` carrying the
+ * parser's code: a version other than v1, an undefined revocation reason, an empty or repeated
+ * extension, an empty `responses`, a nonce outside 1..128 octets, a malformed archive cutoff or
+ * CRL reference, a responseStatus that disagrees with responseBytes, and a time not in the
+ * `YYYYMMDDHHMMSSZ` form RFC 5019 requires. What needs the issuer or the signature (responder
+ * authorization, the ResponderID matching the signing certificate, freshness against a clock)
+ * is `pki.ocsp.verify`'s, and the certificates in `certs` are linted with `pki.lint.certificate`.
+ *
+ * @opts  profile   `"rfc6960"` or `"rfc5019"` (default runs the rfc6960 rows and marks the rfc5019
+ *                  rows not applicable). A certificate or CRL profile name is refused rather than
+ *                  run against a response.
+ * @opts  severity  Suppress findings below this floor (default `"notice"`). `counts` and `worst`
+ *                  always reflect the complete, unfiltered result.
+ * @example
+ *   var ca = await pki.key.generate("Ed25519");
+ *   var caKey = await pki.key.export(ca.privateKey);
+ *   var caDer = await pki.x509.sign({ subject: "Example CA", subjectPublicKey: await pki.key.export(ca.publicKey),
+ *     notBefore: new Date("2026-01-01T00:00:00Z"), notAfter: new Date("2036-01-01T00:00:00Z"),
+ *     extensions: { basicConstraints: { cA: true }, keyUsage: ["keyCertSign"], subjectKeyIdentifier: true } }, { key: caKey });
+ *   var leaf = await pki.key.generate("Ed25519");
+ *   var leafDer = await pki.x509.sign({ subject: "leaf.example", subjectPublicKey: await pki.key.export(leaf.publicKey),
+ *     notBefore: new Date("2026-01-01T00:00:00Z"), notAfter: new Date("2036-01-01T00:00:00Z") },
+ *     { cert: caDer, key: caKey });
+ *   var der = await pki.ocsp.sign({ responderID: "byKey", responses: [{ cert: leafDer, issuer: caDer, status: "good" }] },
+ *     { cert: caDer, key: caKey });
+ *   var report = pki.lint.ocsp(der);
+ *   report.findings.length;                              // -> 0
+ *   pki.lint.ocsp(der, { profile: "rfc5019" }).worst;    // -> null
+ */
+function ocsp(input, opts) {
+  opts = guard.identifier.optionsObject(opts, _cfg, "lint/bad-input", "pki.lint options");
+  guard.identifier.assertKnownKeys(opts, _OCSP_OPTS, _cfg, "lint/bad-input",
+    "pki.lint.ocsp has an unknown option: ");
+  if (opts.severity != null && VALID_SEVERITY.indexOf(opts.severity) === -1) {
+    throw _cfg("lint/bad-severity", "unknown severity threshold \"" + opts.severity + "\" (known: " + VALID_SEVERITY.join(", ") + ")");
+  }
+  var profile = opts.profile;
+  var rules_;
+  if (profile == null || profile === "all" || profile === "default") rules_ = ALL_OCSP_RULES;
+  else if (OCSP_PROFILES[profile]) rules_ = OCSP_PROFILES[profile];
+  else if (PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a certificate profile; lint a certificate with pki.lint.certificate");
+  else if (CRL_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a CRL profile; lint a CRL with pki.lint.crl");
+  else throw _cfg("lint/unknown-profile", "unknown OCSP lint profile \"" + profile + "\" (known: " + Object.keys(OCSP_PROFILES).join(", ") + ")");
+
+  var ingested = _ingestOcsp(input);
+  var report;
+  if (ingested.fatal) {
+    report = { findings: [ingested.fatal], ran: [],
+      counts: Object.assign(Object.create(null), { fatal: 1, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 }) };
+  } else if (!ingested.response.basicResponse) {
+    /** @internal A non-successful response carries no BasicOCSPResponse, so every row is not
+     * applicable to it: the profile grades responses, and an error status is not one. */
+    report = { findings: [], ran: [],
+      counts: Object.assign(Object.create(null), { fatal: 0, error: 0, warn: 0, notice: 0, pass: 0, na: rules_.length, ne: 0 }) };
+  } else {
+    report = _runLints(rules_, ingested.response, { profile: profile, decode: function () { return null; }, raw: function () { return null; } });
+  }
+  report.worst = _worst(report.findings);
+  report.findings = _applyThreshold(report, opts.severity);
+  return report;
+}
+
 /**
  * @primitive  pki.lint.rules
  * @signature  pki.lint.rules(profile?) -> [{id, severity, source, citation}]
@@ -1477,8 +2025,8 @@ function crl(input, opts) {
  */
 function rules(profile) {
   var set = profile == null
-    ? ALL_RULES.concat(ALL_CRL_RULES)
-    : (PROFILES[profile] || CRL_PROFILES[profile]
+    ? ALL_RULES.concat(ALL_CRL_RULES).concat(ALL_OCSP_RULES)
+    : (PROFILES[profile] || CRL_PROFILES[profile] || OCSP_PROFILES[profile]
       || (function () { throw _cfg("lint/unknown-profile", "unknown lint profile \"" + profile + "\""); })());
   return set.map(function (r) { return { id: r.id, severity: r.severity, source: r.source, citation: r.citation }; });
 }
@@ -1492,13 +2040,14 @@ function rules(profile) {
  *
  * List the known lint-profile names.
  * @example
- *   pki.lint.profiles();   // -> ["rfc5280", "rfc9881", "rfc9909", "rfc9935", "cabf-tls", "rfc5280-crl"]
+ *   pki.lint.profiles();   // -> ["rfc5280", "rfc9881", "rfc9909", "rfc9935", "cabf-tls", "rfc5280-crl", "rfc6960", "rfc5019"]
  */
-function profiles() { return Object.keys(PROFILES).concat(Object.keys(CRL_PROFILES)); }
+function profiles() { return Object.keys(PROFILES).concat(Object.keys(CRL_PROFILES)).concat(Object.keys(OCSP_PROFILES)); }
 
 module.exports = {
   certificate: certificate,
   crl: crl,
+  ocsp: ocsp,
   rules: rules,
   profiles: profiles,
 };

package/lib/pki-build.js

@@ -317,17 +317,9 @@ function reqDenseArrayImpl(list, what, E, code) {
   return out;
 }
 
-/** @internal RFC 5280 sec. 4.2 fixes the criticality of these certificate extensions. Each entry maps
- *  the extension OID to the flag the RFC requires and the clause that sets it. */
-var CERT_FIXED_CRITICALITY = intrinsic.create(null);
-[["authorityKeyIdentifier", false, "RFC 5280 sec. 4.2.1.1"], ["subjectKeyIdentifier", false, "RFC 5280 sec. 4.2.1.2"],
-  ["subjectDirectoryAttributes", false, "RFC 5280 sec. 4.2.1.8"], ["nameConstraints", true, "RFC 5280 sec. 4.2.1.10"],
-  ["policyConstraints", true, "RFC 5280 sec. 4.2.1.11"], ["inhibitAnyPolicy", true, "RFC 5280 sec. 4.2.1.14"],
-  ["freshestCRL", false, "RFC 5280 sec. 4.2.1.15"], ["authorityInfoAccess", false, "RFC 5280 sec. 4.2.2.1"],
-  ["subjectInfoAccess", false, "RFC 5280 sec. 4.2.2.2"],
-  ["precertificatePoison", true, "RFC 6962 sec. 3.1"]].forEach(function (r) {
-  CERT_FIXED_CRITICALITY[oid.byName(r[0])] = { critical: r[1], citation: r[2] };
-});
+/** @internal The criticality RFC 5280 sec. 4.2 fixes for a certificate extension, by OID, read from
+ *  the shared table the certificate lint profile reports from, so the two cannot disagree. */
+var CERT_FIXED_CRITICALITY = pkix.certFixedCriticality(oid);
 
 var NC_KEYS = intrinsic.assign(intrinsic.create(null), { permitted: 1, excluded: 1 });
 var NC_FORM_TAG = intrinsic.assign(intrinsic.create(null), {

package/lib/schema-crl.js

@@ -239,4 +239,9 @@ module.exports = {
   pemDecode: pemDecode,
   pemEncode: pemEncode,
   matches: matches,
+  /** @internal The reader this parser applies to a CRL entry extension (reasonCode, invalidityDate),
+   *  for a consumer that meets the same extension elsewhere: RFC 6960 sec. 4.4.5 carries every CRL
+   *  entry extension into an OCSP SingleResponse, and the linter reads it with this rather than a
+   *  second one. Not on the curated `pki.schema.crl` surface. */
+  decodeExtension: decodeExt,
 };

package/lib/schema-ocsp.js

@@ -297,6 +297,7 @@ var BASIC_OCSP_RESPONSE = schema.seq([
       signatureAlgorithm: m.fields.signatureAlgorithm.value.result,
       signature: _rawSignature(m.fields.signature),
       certs: m.fields.certs.present ? m.fields.certs.value.items.map(function (it) { return it.value; }) : [],
+      certsPresent: m.fields.certs.present,
     };
   },
 });
@@ -459,8 +460,10 @@ var parseRequest = pkix.makeParser({ pemLabel: "OCSP REQUEST", PemError: PemErro
  * Parse a DER `Buffer` or a PEM (`OCSP RESPONSE`) string into a structured
  * OCSPResponse: `{ responseStatus, responseBytes, basicResponse }`. For a successful
  * basic response, `basicResponse` carries `{ tbsResponseDataBytes, responderID,
- * producedAt, responses, signatureAlgorithm, signature, certs }`; each
- * `responses[i].certStatus` is `{ type: "good" | "revoked" | "unknown" }`. A
+ * producedAt, responses, signatureAlgorithm, signature, certs, certsPresent }`; each
+ * `responses[i].certStatus` is `{ type: "good" | "revoked" | "unknown" }`. `certs` is the
+ * embedded certificate list, empty when the field is absent, and `certsPresent` says
+ * whether the response carried the field at all. A
  * non-successful status carries no `responseBytes`. A malformed structure throws a
  * typed `OcspError` (`ocsp/*`); an unsupported `responseType` throws
  * `ocsp/unsupported-response-type`.

package/lib/schema-pkix.js

@@ -458,6 +458,29 @@ function rawNonEmptySequence(ns, opts) {
 
 var CRL_REASON_NAMES = constants.NAMES.CRL_REASON;
 
+/** @internal The criticality RFC 5280 (and RFC 6962 for the poison) fixes for a certificate
+ *  extension, by extension name, each with its clause. One table for the two consumers that state
+ *  the rule: the certificate signer refuses to write an extension against it, and the certificate
+ *  lint profile reports one that arrived against it. Extensions whose criticality the CA chooses
+ *  (basicConstraints, keyUsage, the alternative names) are absent. */
+var CERT_FIXED_CRITICALITY_ROWS = [
+  ["authorityKeyIdentifier", false, "RFC 5280 sec. 4.2.1.1"], ["subjectKeyIdentifier", false, "RFC 5280 sec. 4.2.1.2"],
+  ["subjectDirectoryAttributes", false, "RFC 5280 sec. 4.2.1.8"], ["nameConstraints", true, "RFC 5280 sec. 4.2.1.10"],
+  ["policyConstraints", true, "RFC 5280 sec. 4.2.1.11"], ["inhibitAnyPolicy", true, "RFC 5280 sec. 4.2.1.14"],
+  ["freshestCRL", false, "RFC 5280 sec. 4.2.1.15"], ["authorityInfoAccess", false, "RFC 5280 sec. 4.2.2.1"],
+  ["subjectInfoAccess", false, "RFC 5280 sec. 4.2.2.2"],
+  ["precertificatePoison", true, "RFC 6962 sec. 3.1"],
+];
+/** @internal The table keyed by dotted OID through the registry the caller passes, since this
+ *  module takes its registry as a parameter rather than requiring it. */
+function certFixedCriticality(oidRegistry) {
+  var table = _create(null);
+  _forEach(CERT_FIXED_CRITICALITY_ROWS, function (r) {
+    table[oidRegistry.byName(r[0])] = { critical: r[1], citation: r[2] };
+  });
+  return table;
+}
+
 var GN_CONSTRUCTED = _assign(_create(null), { 0: 1, 3: 1, 4: 1, 5: 1 });
 var GN_IA5 = _assign(_create(null), { 1: 1, 2: 1, 6: 1 });
 /** @internal DirectoryString ::= CHOICE { teletexString, printableString, universalString,
@@ -1439,6 +1462,7 @@ module.exports = {
   utf8Text: utf8Text,
   rawNonEmptySequence: rawNonEmptySequence,
   CRL_REASON_NAMES: CRL_REASON_NAMES,
+  certFixedCriticality: certFixedCriticality,
   certExtensionDecoders: certExtensionDecoders,
   _decodeHelpers: _decodeHelpers,
   attribute: attribute,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:6c1d7d34-8c46-44b5-aab6-26ca7c728d37",
+  "serialNumber": "urn:uuid:c684e528-5bc7-435f-8e5c-076712d49f7f",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-12T02:32:19.183Z",
+    "timestamp": "2026-09-12T04:29:07.726Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.7.25",
+      "bom-ref": "@blamejs/pki@0.7.27",
       "type": "application",
       "name": "pki",
-      "version": "0.7.25",
+      "version": "0.7.27",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
-      "purl": "pkg:npm/%40blamejs/pki@0.7.25",
+      "purl": "pkg:npm/%40blamejs/pki@0.7.27",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.7.25",
+      "ref": "@blamejs/pki@0.7.27",
       "dependsOn": []
     }
   ]