@blamejs/pki 0.7.37 → 0.7.39

package/CHANGELOG.md

@@ -4,6 +4,28 @@ 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.39 — 2026-09-12
+
+An OCSP CertID's issuer hashes are held to the length of the digest they name.
+
+### Changed
+
+- pki.schema.ocsp.parseRequest and parseResponse refuse a CertID whose issuerNameHash or issuerKeyHash is not the length of the digest its hashAlgorithm names (ocsp/bad-cert-id, RFC 6960 sec. 4.1.1), for SHA-1, SHA-256, SHA-384, SHA-512, SHA3-256 and SHA3-512; a CertID under a digest this build does not know is read as given. pki.ocsp.verify and pki.ocsp.verifyRequest, which parse first, report such a request or response as malformed instead of comparing a hash that could never match.
+- The digest output lengths live in pki.constants.NAMES.DIGEST_OCTETS, read by the OCSP parser and by pki.tsp.sign and pki.tsp.verify for the messageImprint length check they already made.
+
+## v0.7.38 — 2026-09-12
+
+pki.lint.certificate grades six RFC 5280 rules its parser read past, and the parser surfaces the unique identifiers.
+
+### Added
+
+- pki.lint.certificate rules: lint/rfc5280/policy-mapping-any-policy (error, sec. 4.2.1.5: policies MUST NOT be mapped to or from anyPolicy), lint/rfc5280/unique-identifier-present (error, sec. 4.1.2.8: a conforming CA MUST NOT generate a certificate with a unique identifier), lint/rfc5280/san-critical-with-subject (warn, sec. 4.2.1.6: a subjectAltName beside a non-empty subject SHOULD be non-critical), lint/rfc5280/eku-critical-with-any-purpose (warn, sec. 4.2.1.12: an extKeyUsage naming anyExtendedKeyUsage SHOULD NOT be critical), lint/rfc5280/notice-ref-used (warn, sec. 4.2.1.4: noticeRef SHOULD NOT be used), and lint/rfc5280/recommended-criticality (warn, sec. 4.2.1.7 and 4.2.1.13: issuerAltName and cRLDistributionPoints SHOULD be non-critical), each naming its clause in the finding.
+- pki.schema.x509.parse returns issuerUniqueID and subjectUniqueID, each { unusedBits, bytes } or null, so a relying party sees the fields RFC 5280 sec. 4.1.2.8 tells a CA not to generate.
+
+### Changed
+
+- pki.x509.sign refuses a pre-encoded policyMappings extension that maps to or from anyPolicy, the rule its object form and pki.path.validate already applied (RFC 5280 sec. 4.2.1.5).
+
 ## v0.7.37 — 2026-09-12
 
 Every object a signer reads refuses a field it does not read, a signed OCSP request names its signer, and the requester nonce meets the RFC 9654 floor.

package/README.md

@@ -252,7 +252,7 @@ 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, 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.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) and the two it should (issuerAltName, cRLDistributionPoints), a policy mapping to or from anyPolicy, a unique identifier a conforming CA must not generate, a critical subjectAltName beside a non-empty subject, a critical extKeyUsage naming anyExtendedKeyUsage, a userNotice noticeRef, 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\|crl\|ocsp-response>`, `pki convert <file> --to der\|pem`, `pki verify <cert>... --anchor <cert>`, `pki sign <file> --cert <c> --key <k>` |

package/lib/constants.js

@@ -238,6 +238,11 @@ var NAMES = Object.assign(Object.create(null), {
     "SLH-DSA-SHA2-128s": "SLH-DSA-SHA2-128s", "SLH-DSA-SHA2-128f": "SLH-DSA-SHA2-128f",
     "SLH-DSA-SHA2-192s": "SLH-DSA-SHA2-192s", "SLH-DSA-SHA2-256s": "SLH-DSA-SHA2-256s",
   },
+  /** @internal The output length in octets of each fixed-length digest, by the OID registry's name
+   * (FIPS 180-4, FIPS 202). A structure that carries "the hash of X under algorithm A" is held to
+   * this length: an OCSP CertID's issuer hashes, a timestamp's messageImprint. The XOFs (SHAKE) have
+   * no single length and are absent. */
+  DIGEST_OCTETS: { sha1: 20, sha256: 32, sha384: 48, sha512: 64, "sha3-256": 32, "sha3-512": 64 },
 });
 
 /** @internal Each inner table is looked up by a name a certificate supplies, so it answers from

package/lib/guard-parsed.js

@@ -79,6 +79,8 @@ function isCert(o) {
     !!o.subjectPublicKeyInfo && _isBuffer(o.subjectPublicKeyInfo.bytes) &&
     _isAlgorithmIdentifier(o.subjectPublicKeyInfo.algorithm) &&
     _isBitString(o.subjectPublicKeyInfo.publicKey) &&
+    (o.issuerUniqueID === null || _isBitString(o.issuerUniqueID)) &&
+    (o.subjectUniqueID === null || _isBitString(o.subjectUniqueID)) &&
     _isArray(o.extensions) && _every(o.extensions, _isExtensionEntry);
 }
 

package/lib/lint.js

@@ -234,6 +234,13 @@ function _ecCurveName(spki) {
 }
 
 var OID_UNOTICE = oid.byName("unotice");
+var OID_ANY_POLICY = oid.byName("anyPolicy");
+/** @internal The extensions RFC 5280 says a conforming CA SHOULD mark non-critical, keyed by OID
+ *  with the clause; the MUSTs live in the shared CERT_FIXED_CRITICALITY table. The subjectAltName
+ *  and extKeyUsage recommendations are conditional and have their own rules. */
+var CERT_RECOMMENDED_NON_CRITICAL = Object.create(null);
+CERT_RECOMMENDED_NON_CRITICAL[oid.byName("issuerAltName")] = "RFC 5280 sec. 4.2.1.7";
+CERT_RECOMMENDED_NON_CRITICAL[oid.byName("cRLDistributionPoints")] = "RFC 5280 sec. 4.2.1.13";
 var _T_BMP = asn1.TAGS.BMP_STRING, _T_VISIBLE = asn1.TAGS.VISIBLE_STRING, _T_UTF8 = asn1.TAGS.UTF8_STRING;
 function _hasControlChar(str) {
   for (var i = 0; i < str.length; i++) {
@@ -397,6 +404,67 @@ var RFC5280_RULES = [
     "RFC 5280 4.2.1.14", "the inhibitAnyPolicy extension must be marked critical"),
   _criticalityRule("keyUsage", "lint/rfc5280/key-usage-not-critical", "warn",
     "RFC 5280 4.2.1.3", "the keyUsage extension should be marked critical"),
+  {
+    id: "lint/rfc5280/recommended-criticality", severity: "warn", source: "rfc5280", citation: "RFC 5280 4.2.1.7 / 4.2.1.13",
+    message: "an extension a conforming CA should mark non-critical is marked critical",
+    check: function (cert) {
+      var rows = [];
+      (cert.extensions || []).forEach(function (e) {
+        var row = CERT_RECOMMENDED_NON_CRITICAL[e.oid];
+        if (row === undefined || e.critical !== true) return;
+        rows.push({ context: { extension: e.name || e.oid, oid: e.oid, recommended: "non-critical", was: "critical", citation: row } });
+      });
+      return rows.length ? rows : null;
+    },
+  },
+  {
+    id: "lint/rfc5280/policy-mapping-any-policy", severity: "error", source: "rfc5280", citation: "RFC 5280 4.2.1.5",
+    message: "a policy mapping names anyPolicy as its issuer or subject domain policy, which a mapping must not do",
+    appliesTo: function (cert, ctx) { return !!ctx.raw("policyMappings"); },
+    check: function (cert, ctx) {
+      var d = ctx.decode("policyMappings");
+      if (!d || !Array.isArray(d.value)) return null;
+      var bad = d.value.filter(function (m) { return m.issuerDomainPolicy === OID_ANY_POLICY || m.subjectDomainPolicy === OID_ANY_POLICY; });
+      return bad.length ? { context: { count: bad.length } } : null;
+    },
+  },
+  {
+    id: "lint/rfc5280/unique-identifier-present", severity: "error", source: "rfc5280", citation: "RFC 5280 4.1.2.8",
+    message: "the certificate carries a unique identifier, which a conforming CA must not generate",
+    check: function (cert) {
+      var which = [];
+      if (cert.issuerUniqueID) which.push("issuerUniqueID");
+      if (cert.subjectUniqueID) which.push("subjectUniqueID");
+      return which.length ? { context: { fields: which } } : null;
+    },
+  },
+  {
+    id: "lint/rfc5280/san-critical-with-subject", severity: "warn", source: "rfc5280", citation: "RFC 5280 4.2.1.6",
+    message: "a subjectAltName beside a non-empty subject should be marked non-critical",
+    appliesTo: function (cert, ctx) { return !!ctx.raw("subjectAltName"); },
+    check: function (cert, ctx) {
+      var e = ctx.raw("subjectAltName");
+      return (e.critical === true && cert.subject.rdns.length > 0) ? true : null;
+    },
+  },
+  {
+    id: "lint/rfc5280/eku-critical-with-any-purpose", severity: "warn", source: "rfc5280", citation: "RFC 5280 4.2.1.12",
+    message: "an extKeyUsage that names anyExtendedKeyUsage should not be marked critical",
+    appliesTo: function (cert, ctx) { return !!ctx.raw("extKeyUsage"); },
+    check: function (cert, ctx) {
+      var e = ctx.raw("extKeyUsage");
+      return (e.critical === true && _hasEku(cert, "anyExtendedKeyUsage")) ? true : null;
+    },
+  },
+  {
+    id: "lint/rfc5280/notice-ref-used", severity: "warn", source: "rfc5280", citation: "RFC 5280 4.2.1.4",
+    message: "a userNotice policy qualifier carries a noticeRef, which should not be used",
+    appliesTo: _hasPolicyDisplayText,
+    check: function (cert, ctx) {
+      var refs = _policyDisplayTexts(ctx).filter(function (d) { return d.field === "organization"; });
+      return refs.length ? { context: { count: refs.length } } : null;
+    },
+  },
   {
     id: "lint/rfc5280/ski-missing-ee", severity: "notice", source: "rfc5280", citation: "RFC 5280 4.2.1.2",
     message: "an end-entity certificate should carry a subjectKeyIdentifier extension",

package/lib/schema-ocsp.js

@@ -183,9 +183,19 @@ var CERT_ID = schema.seq([
   schema.field("serialNumber", schema.integerLeaf()),
 ], {
   assert: "sequence", arity: { exact: 4 }, code: "ocsp/bad-cert-id", what: "CertID",
+  /** @internal RFC 6960 sec. 4.1.1: issuerNameHash and issuerKeyHash are the hashes of the issuer's
+   *  name and key "using the hash algorithm specified in hashAlgorithm", so each is that digest's
+   *  length; a hash of any other length names no certificate. A digest this build does not know is
+   *  read as given, since its length is not known here. */
   build: function (m) {
+    var hashAlgorithm = m.fields.hashAlgorithm.value.result;
+    var want = constants.NAMES.DIGEST_OCTETS[hashAlgorithm.name];
+    if (want !== undefined) {
+      if (m.fields.issuerNameHash.value.length !== want) throw NS.E("ocsp/bad-cert-id", "CertID issuerNameHash is " + m.fields.issuerNameHash.value.length + " octets, not the " + want + " a " + hashAlgorithm.name + " digest is (RFC 6960 sec. 4.1.1)");
+      if (m.fields.issuerKeyHash.value.length !== want) throw NS.E("ocsp/bad-cert-id", "CertID issuerKeyHash is " + m.fields.issuerKeyHash.value.length + " octets, not the " + want + " a " + hashAlgorithm.name + " digest is (RFC 6960 sec. 4.1.1)");
+    }
     return {
-      hashAlgorithm: m.fields.hashAlgorithm.value.result,
+      hashAlgorithm: hashAlgorithm,
       issuerNameHash: m.fields.issuerNameHash.value,
       issuerKeyHash: m.fields.issuerKeyHash.value,
       serialNumber: m.fields.serialNumber.value,

package/lib/schema-x509.js

@@ -153,6 +153,8 @@ var CERTIFICATE = pkix.signedEnvelope(NS, CERTIFICATE_TBS, {
       subject:               tbs.fields.subject.value.result,
       validity:              tbs.fields.validity.value.result,
       subjectPublicKeyInfo:  tbs.fields.subjectPublicKeyInfo.value.result,
+      issuerUniqueID:        tbs.fields.issuerUniqueID.present ? tbs.fields.issuerUniqueID.value : null,
+      subjectUniqueID:       tbs.fields.subjectUniqueID.present ? tbs.fields.subjectUniqueID.value : null,
       extensions:            hasExtensions ? extField.value.result : [],
       tbsBytes:              e.tbsBytes,
       signatureValue:        e.signatureValue,
@@ -173,10 +175,11 @@ var CERTIFICATE = pkix.signedEnvelope(NS, CERTIFICATE_TBS, {
  * Parse a DER `Buffer` or a PEM string/Buffer into a structured
  * certificate: `{ version, serialNumber, serialNumberHex,
  * signatureAlgorithm, issuer, subject, validity, subjectPublicKeyInfo,
- * extensions, tbsBytes, signatureValue }`. Distinguished names come back
- * both as a rendered `dn` string and as structured `rdns`; the validity
- * window is real `Date`s; `tbsBytes` is the exact signed byte range for a
- * downstream verifier.
+ * issuerUniqueID, subjectUniqueID, extensions, tbsBytes, signatureValue }`.
+ * Distinguished names come back both as a rendered `dn` string and as
+ * structured `rdns`; the validity window is real `Date`s; the two unique
+ * identifiers are `{ unusedBits, bytes }` or null (RFC 5280 sec. 4.1.2.8);
+ * `tbsBytes` is the exact signed byte range for a downstream verifier.
  *
  * Throws `CertificateError` when the bytes are not a well-formed
  * certificate and `Asn1Error` when the underlying DER is malformed.

package/lib/tsp-sign.js

@@ -31,6 +31,7 @@ var frameworkError = require("./framework-error");
 
 var pkix = require("./schema-pkix");
 var pkiBuild = require("./pki-build");
+var constants = require("./constants");
 var TspError = frameworkError.TspError;
 var _NS = pkix.makeNS("tsp", TspError, oid);
 var b = asn1.build;
@@ -48,7 +49,7 @@ var _b = pkiBuild.makeBuilder({
 });
 
 var NODE_DIGEST = intrinsic.assign(intrinsic.create(null), { sha256: "sha256", sha384: "sha384", sha512: "sha512" });
-var HASH_LEN = intrinsic.assign(intrinsic.create(null), { sha256: 32, sha384: 48, sha512: 64 });
+var HASH_LEN = constants.NAMES.DIGEST_OCTETS;
 
 var _REVOCATION_RANK = intrinsic.assign(intrinsic.create(null), { "false": 0, "undetermined": 1, "waived": 2, "determined": 3 });
 function _rankRevocation(v) {
@@ -422,7 +423,7 @@ function parseResponse(input) { return schemaTsp.parse(input); }
 
 
 var _VERIFY_DIGEST = intrinsic.assign(intrinsic.create(null), { sha256: "sha256", sha384: "sha384", sha512: "sha512", sha1: "sha1" });
-var _VERIFY_DIGEST_LEN = intrinsic.assign(intrinsic.create(null), { sha1: 20, sha256: 32, sha384: 48, sha512: 64 });
+var _VERIFY_DIGEST_LEN = constants.NAMES.DIGEST_OCTETS;
 var _BIND_DIGEST = intrinsic.assign(intrinsic.create(null), { sha256: "sha256", sha384: "sha384", sha512: "sha512" });
 
 function _imprintMatches(mi, data) {

package/lib/x509-sign.js

@@ -130,7 +130,7 @@ function _buildExtensions(extSpec, ctx) {
   if (extSpec == null) extSpec = {};
   if (_isArray(extSpec)) {
     var seenExt = intrinsic.create(null), arrCa = false, arrKeyCertSign = false, arrPathLen = false, arrNameConstraints = false;
-    var oidBc = O("basicConstraints"), oidKu = O("keyUsage"), oidNc = O("nameConstraints");
+    var oidBc = O("basicConstraints"), oidKu = O("keyUsage"), oidNc = O("nameConstraints"), oidPm = O("policyMappings");
     var arr = extSpec.map(function (e, i) {
       var der = _reqDer(e, "extension");
       _assertValidExtension(der, i, EXT_DECODERS);
@@ -153,6 +153,7 @@ function _buildExtensions(extSpec, ctx) {
           if (arrCa && n.children.length !== 3) throw _err("x509/bad-input", "a CA certificate's basicConstraints MUST be critical (RFC 5280 sec. 4.2.1.9)");
         }
         else if (extnId === oidKu) { arrKeyCertSign = decoded.keyCertSign === true; }
+        else if (extnId === oidPm) { _assertNoAnyPolicyMapping(decoded); }
       }
       return b.raw(der);
     });
@@ -272,6 +273,17 @@ function _buildExtensions(extSpec, ctx) {
  *  the log answers, reconstructed from the other by removing this extension. A certificate carrying
  *  both names no stage of that exchange, and the SCTs in it could never verify. Both the typed spec
  *  and the pre-encoded array reach the same certificate, so both are held to it here. */
+/** @internal RFC 5280 sec. 4.2.1.5: "Policies MUST NOT be mapped either to or from the special
+ *  value anyPolicy." The object form's encoder refuses it as it builds; the pre-encoded form is
+ *  held to the same clause on the decoded value. */
+function _assertNoAnyPolicyMapping(mappings) {
+  var anyPolicy = O("anyPolicy");
+  for (var i = 0; i < mappings.length; i++) {
+    if (mappings[i].issuerDomainPolicy === anyPolicy || mappings[i].subjectDomainPolicy === anyPolicy) {
+      throw _err("x509/bad-input", "pre-encoded policyMappings entry " + i + " maps to or from anyPolicy, which RFC 5280 sec. 4.2.1.5 forbids");
+    }
+  }
+}
 function _assertCtStagesExclusive(hasPoison, hasSctList) {
   if (hasPoison && hasSctList) {
     throw _err("x509/bad-input", "precertificatePoison names a precertificate and signedCertificateTimestampList names the certificate issued after it, so a certificate carries one or the other (RFC 6962 sec. 3.2)");
@@ -402,11 +414,12 @@ function _hasCriticalSan(extSpec) {
  * skip count (sec. 4.2.1.14); both are emitted critical, which those clauses require.
  * `extensions.policyMappings` takes a list of `{ issuerDomainPolicy, subjectDomainPolicy }` naming
  * registered policies or dotted OIDs, and refuses a mapping to or from `anyPolicy`, which sec.
- * 4.2.1.5 forbids, the same rule `pki.path.validate` applies at sec. 6.1.4(a). That clause states a
- * SHOULD for marking it critical. The validator processes the extension on an intermediate
- * certificate, where sec. 6.1.4 applies the mappings to the policy tree, and treats a critical one on
- * the TARGET certificate as unprocessed, rejecting it; `pki.lint.certificate` grades that case
- * `unknown-critical-extension`. It is emitted non-critical unless `policyMappingsCritical` is set.
+ * 4.2.1.5 forbids, the same rule `pki.path.validate` applies at sec. 6.1.4(a); the pre-encoded
+ * form is held to it too. That clause states a SHOULD for marking it critical. The validator
+ * processes the extension on an intermediate certificate, where sec. 6.1.4 applies the mappings to
+ * the policy tree, and treats a critical one on the TARGET certificate as unprocessed, rejecting it;
+ * `pki.lint.certificate` grades that case `unknown-critical-extension`. It is emitted non-critical
+ * unless `policyMappingsCritical` is set.
  * `extensions.issuerAltName` takes the `GeneralName` forms `subjectAltName` takes and is emitted
  * non-critical (sec. 4.2.1.7).
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.7.37",
+  "version": "0.7.39",
   "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:6602edcd-778a-4204-8e53-1bc40ccb396c",
+  "serialNumber": "urn:uuid:5b3f8b70-36de-4855-8e1e-c6d22b99d982",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-12T13:27:30.472Z",
+    "timestamp": "2026-09-12T14:40:25.102Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.7.37",
+      "bom-ref": "@blamejs/pki@0.7.39",
       "type": "application",
       "name": "pki",
-      "version": "0.7.37",
+      "version": "0.7.39",
       "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.37",
+      "purl": "pkg:npm/%40blamejs/pki@0.7.39",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.7.37",
+      "ref": "@blamejs/pki@0.7.39",
       "dependsOn": []
     }
   ]