@blamejs/pki 0.8.14 → 0.8.16

package/CHANGELOG.md

@@ -4,6 +4,40 @@ 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.8.16 — 2026-09-24
+
+A certification request is linted before it is issued, against the rows its certificate will be held to.
+
+### Added
+
+- `pki.lint.csr(pem | der | parsed, opts?)` lints a PKCS#10 certification request and returns the `LintReport` shape the other lint verbs return. It never throws on the data path: bytes that are not a well-formed request produce a single `fatal` finding `lint/unparseable` carrying the strict parser's own code.
+- The `rfc2986` profile covers what the request asks for: an empty subject that names no identity, an empty subject whose subjectAltName is not critical (RFC 5280 section 4.1.2.6), a request for an extension the issuer determines rather than takes from a request, a request asking for a CA certificate, a request signed under a broken digest, and a challengePassword traveling inside the request. The broken digests are named outright rather than read out of the algorithm name, because `shaWithRSAEncryption` is the original SHA, now SHA-0, and its name carries no digest to read.
+- `opts.profile: "cabf-tls"` adds the CA/Browser Forum rows: a commonName no subjectAltName covers, a malformed requested dNSName, a request naming no subjectAltName, and a key below the TLS minimum. They run only when named, because a request carries no extKeyUsage and nothing in its bytes says it is for TLS. Each is the certificate profile's own row, applied to what the request asks for.
+- A request carrying more than one extensionRequest attribute is reported, and each is linted as the request it states. Two parse where they sort in DER order, and a reader asking for an extension by name takes the first match, so a basicConstraints of cA FALSE in one attribute would otherwise hide a cA TRUE in the next and the answer would be decided by how the bytes happened to sort.
+- A requested extension whose value does not decode under its own syntax is reported, by the RFC 5280 section 4.2 row the certificate profile already carries. It counted as a passing check before, because the shared decoder returns null for a value it cannot read and every row asking for an extension by name reads that null as absence.
+- The weak-digest row reads an RSASSA-PSS request's digest from its parameters rather than its algorithm name. RFC 4055 section 3.1 makes the hashAlgorithm field default to SHA-1, so absent parameters and an empty parameter sequence both name SHA-1: the encoding that appears to say nothing names the weakest digest.
+- `pki.lint.rules("rfc2986")` lists the new rows with their citations, and `pki.lint.profiles()` enumerates `rfc2986` alongside the existing names.
+- `pki.lint.rules(profile, artifact)` takes an optional second argument, one of `"certificate"`, `"csr"`, `"crl"` or `"ocsp"`. `"cabf-tls"` names a set for both a certificate and a request and the two are not the same rows, so without it a reader asking about the request was given the certificate-only extKeyUsage and validity rows and none of the structural ones. Calls passing one argument are unchanged. Each id now appears once in the listing, including where two artifacts run the same rule.
+
+### Changed
+
+- `md2WithRSAEncryption`, `md4WithRSAEncryption-pkcs1`, `md5WithRSAEncryption`, `sha1WithRSAEncryption`, `ecdsaWithSHA1` and `dsaWithSha1` resolve through `pki.oid`, so an artifact signed under one reads back with a name instead of a bare dotted string. The weak-digest row reads that name, so an algorithm the registry could not name passed it silently. Nothing signs or verifies from that registry: the signing and verifying paths carry their own tables and neither has a row for these, so naming one does not make it usable. A request or certificate carrying one still fails to verify.
+- Every name in the OID registry resolves back to the OID it names, which is now checked. The registry is two-way and its directions did not agree about a repeated name: the first `name -> OID` registration was kept while `OID -> name` took the last, so adding a name a family already held would silently repoint every lookup of it and leave the original OID still answering with that name. X.501 and X.520 both standardize `clearance`, at 2.5.1.5.55 and 2.5.4.55, and that pair is recorded as the one intended duplicate. PKCS#1's MD4 signature is registered as `md4WithRSAEncryption-pkcs1` for the same reason: the plain name already belongs to the OIW arc's 1.3.14.3.2.4.
+
+## v0.8.15 — 2026-09-24
+
+The host's own CA bundle becomes trust anchors, and says which set you got.
+
+### Added
+
+- `pki.trust.systemAnchors(opts?)` returns `{ anchors, source, path, skipped }`. `source` is `"ca-bundle"` for a file on this host, with `path` naming it, or `"node-bundled"` for the Mozilla set compiled into Node, whose `path` is `null`. The anchors are the same shape `parseCertdata` and `parseCcadbCsv` produce, so they reach `pki.path.validate` without being mapped by hand. `opts.path` reads a named file, `opts.maxBytes` caps the read.
+- The searched locations are the bundles a Unix host keeps: `/etc/ssl/certs/ca-certificates.crt`, `/etc/pki/tls/certs/ca-bundle.crt`, `/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem`, `/etc/ssl/ca-bundle.pem`, `/etc/ssl/cert.pem` and `/usr/local/share/certs/ca-root-nss.crt`. Each candidate is tried by reading it, so one that exists but cannot be opened does not strand a readable one below it.
+- `pki.trust.discoversBundles(platform)` says whether that search runs. It does not on macOS or Windows: `/etc/ssl/cert.pem` can exist on macOS as OpenSSL's own copy, and returning it would report anchors that omit both locally installed roots and the Keychain trust decisions the host actually applies. Those platforms are refused instead, and `opts.path` still reads an exported bundle anywhere.
+- A host with no readable bundle is refused with `trust/no-readable-store`, and the message names the command that exports its roots. macOS keeps them in a binary keychain and Windows in a registry-backed store; reading either means running another program, which this toolkit does not do. `opts.allowNodeBundle: true` returns Node's set instead, reported as `"node-bundled"` so the difference is visible.
+- A block the bundle carries that is not a certificate, and a certificate the strict reader refuses, are both listed in `skipped` with the label, the byte offset and the reason. A CA bundle is distribution-managed and carries certificates that do not conform: the set Node ships has a root whose validity dates are before 2050 and encoded as GeneralizedTime, which RFC 5280 section 4.1.2.5 requires to be UTCTime. Refusing the whole file over one such root would leave you with no anchors, so it is named instead. A bundle from which no certificate parsed is still refused. A `BEGIN` boundary that does not start its line is reported too: RFC 7468 section 2 reads it as text rather than as a block, which in a trust bundle is an anchor you believe you installed and do not have.
+- An OpenSSL `TRUSTED CERTIFICATE` block is reported rather than ingested. It carries the purposes the operator trusted the root FOR in a trailing `X509_CERT_AUX`, and reading the certificate while dropping that would turn a root restricted to one purpose into an unrestricted anchor. The reported reason names the conversion, `openssl x509 -in <file> -out <file>.pem`. Reading the auxiliary data and keeping its restrictions is not yet implemented.
+- `opts.maxBytes` bounds what is read rather than what is kept, so a bundle far above the cap is refused without being loaded. A bundle that exceeds it is refused even under `opts.allowNodeBundle`: the cap is a fault about the file you named, and a resource refusal must not quietly swap the trust set a validation runs against.
+
 ## v0.8.14 — 2026-09-24
 
 The 0.8.14 tarball is the one to install for everything 0.8.13 added.

package/README.md

@@ -283,14 +283,14 @@ comment blocks, is at [pkijs.com](https://pkijs.com).
 | `pki.ocsp` | Online Certificate Status Protocol (RFC 6960), both the responder and relying-party surface. `buildRequest(query, opts)` builds an OCSPRequest for one or more `{ cert, issuer }` pairs, with the CertID hashed under SHA-1 by default per the RFC 5019 lightweight profile (obsoleted by RFC 9919) or under SHA-2, plus an optional RFC 9654 nonce (32 to 128 octets, the requester floor that section sets) and an optional requestor signature, under which the signer certificate's subject is the requestorName unless one is stated (RFC 6960 §4.1.2). `sign(responseData, responder, opts)` produces a signed BasicOCSPResponse over the exact `ResponseData` DER, from the issuing CA directly or a delegated responder, under any `pki.cms.sign` key including the post-quantum ML-DSA and SLH-DSA sets, with `good`, `revoked` (reason and time), or `unknown` per-certificate status, and per-response `singleExtensions` naming the §4.4.4 archive cutoff and the §4.4.2 CRL reference as fields, each read back by name by the parser. The signer refuses what its own lint would grade an error: a pre-encoded singleExtension that RFC 6960 places in requests or in responseExtensions, a CRL entry extension carried at the wrong criticality, and CRL references or entry extensions on a non-issued response, which itself places the §4.4.8 extended revoked definition in responseExtensions without being asked. `buildErrorResponse(status)` produces the unsigned §2.3 error (`tryLater`, `unauthorized`, and the rest). `verify(response, opts)` verifies a response fail-closed against the same hardened gates `pki.path.ocspChecker` runs: the CertID binding, responder authorization (the issuing CA, or a CA-issued delegate bearing id-kp-OCSPSigning and id-pkix-ocsp-nocheck and passing the full out-of-path certificate gates), the signature over `tbsResponseDataBytes`, currency against `thisUpdate` and `nextUpdate`, and the request-nonce echo. It returns `{ status: "good" / "revoked" / "unknown", ... }` and never silently accepts. `verifyRequest(request, opts)` is the responder-side inverse of `buildRequest`: it verifies a client's signed request (RFC 6960 §4.1.1) under the requestor certificate the request carries, trying each embedded certificate since the field is unordered, and reports `signed`, `signatureValid`, every certificate whose key verified the signature and whose subject is the `requestorName` the request states (`signerCerts`, so a key carried under an expired certificate beside its renewal is not hidden behind ordering, while a same-key certificate under another name is not the requestor) with the first one's decoded subject, the full embedded certificate bag (`certs`, including intermediates for path building), and the request's CertIDs; the name check is reported as `requestorNamed` (RFC 6960 §4.1.2) and `valid` requires it, a request no verifying certificate names falls back to listing the verifying ones with `valid: false`, and an unsigned request is reported with `signed: false` rather than refused. Transport-free — `buildRequest`, `sign`, `buildErrorResponse`, `verify`, `verifyRequest` |
 | `pki.ct` | Certificate Transparency (RFC 6962). `parseSctList` decodes the `SignedCertificateTimestampList` a certificate or OCSP response carries, a TLS-presentation-language payload inside the §3.3 double DER wrap, into per-SCT log id, exact `timestamp` (BigInt), named signature algorithm, and raw signature. `reconstructSignedData` rebuilds the exact `digitally-signed` preimage, and `verifySct` verifies an SCT signature against a log's public key, routing an ECDSA signature through the strict DER-conformance gate and verifying through the crypto engine, resolving true or false and throwing a typed error on a structural fault. On the producing side, `encodeSctList` builds the extension value byte for byte as the exact inverse of `parseSctList`, and `signSct` performs a log's signing step. For trust, `parseLogList` ingests the CT log-list JSON into constraint-carrying trusted logs, recomputing each log's id as SHA-256 of its key and refusing a disagreeing id (a swapped key, §3.2) and decoding the state and temporal-interval constraints; `verifySctWithLogList` resolves the log key from an SCT's log id, enforces the state (usable, qualified, and readonly trusted; retired only before retirement; pending and rejected refused) and the temporal-interval window, then delegates the signature check to `verifySct`. `verifyLogListSignature(json, signature, publicKey)` verifies the detached `log_list.sig` over the raw log-list bytes against a caller-pinned signer key (RSASSA-PKCS1-v1.5/SHA-256 and an EC P-256 arm, with forgeable-key defenses failing closed), cross-checked against `openssl dgst`. `fetchLogList(opts)` turns that chain into a live client: it GETs the `log_list.json` and its detached `log_list.sig` over `pki.transport`, verifies the detached signature over the raw fetched bytes against a caller-pinned distributor key before parsing, so an unverified document is never parsed, read, cached, or surfaced, then ingests the same bytes through `parseLogList` and returns the trusted-log set plus the surfaced `version` and `timestamp`. Above the per-SCT layer, `verifySctList` renders a certificate-level verdict over every SCT a certificate carries (§3.3), reporting how many distinct trusted logs verified an SCT (so a duplicated SCT cannot inflate the count) and from how many distinct trusted operators against a caller's CT policy (`minScts` and `minOperators`, both defaulting to the RFC floor of one), where a policy shortfall is a verdict and a per-SCT failure is a recorded row rather than a thrown call; `x509CertEntry` reconstructs the precertificate log entry from a final certificate by removing the SCT-list extension from its TBSCertificate as byte surgery, so its embedded SCTs verify end to end (§3.2). The toolkit bakes in no vendor URL or key, TLS trust is explicit with `rejectUnauthorized` always on, each response is size-capped before the trust chain, and the transport is injectable so the whole path is testable offline — `parseSctList`, `reconstructSignedData`, `verifySct`, `encodeSctList`, `signSct`, `parseLogList`, `verifySctWithLogList`, `verifySctList`, `x509CertEntry`, `verifyLogListSignature`, `fetchLogList` |
 | `pki.merkle` | Merkle-tree proof verification (RFC 6962 / RFC 9162). `leafHash`, `nodeHash`, and `emptyRootHash` build the domain-separated (0x00 leaf, 0x01 node) SHA-256 tree hashes. `verifyInclusion` folds an audit proof back to a root, and `verifyConsistency` reconstructs both the old and new root, which is the append-only guarantee; each is constant-time-compared to a trusted checkpoint root. Fail-closed on bad geometry, sync hashing, transport-free — `leafHash`, `nodeHash`, `emptyRootHash`, `verifyInclusion`, `verifyConsistency` |
-| `pki.trust` | Mozilla and CCADB trust-store ingestion. `parseCertdata` reads the NSS `certdata.txt` object stream and `parseCcadbCsv` the CCADB CSV export, both into one constraint-carrying anchor shape: the per-purpose trust bits, where only `CKT_NSS_TRUSTED_DELEGATOR` grants, and the per-purpose distrust-after dates the bare root list omits. Certificate and trust objects pair by byte-exact issuer and serial rather than adjacency and are cross-checked against the parsed DER, so metadata cannot attach to the wrong root. `anchor()` hands an entry to `pki.path.validate({ trustAnchors, checkPurpose })`, and `anchor(entry, { nameConstraints })` attaches the namespace a root program trusts a root for when that is narrower than the root certificate states, a `{ permitted, excluded }` pair of `{ tag, base }` subtrees that `validate` seeds as the RFC 5280 §6.1.1(h)(i) initial value, intersecting with each certificate's own constraints. `parseTrustAnchorList` reads the IETF's own interchange format for the same thing, an RFC 5914 `TrustAnchorList`, into the same entries, so a list a root program publishes drives `validate` without being mapped by hand. An RFC 5914 anchor's constraints are applied as RFC 5937 §3.2 states, which is that the stricter of the anchor's value and the caller's always wins: its name constraints intersect the caller's permitted subtrees and union its excluded ones, its policy set intersects `userInitialPolicySet`, each of its policy flags may turn the matching `initial*` option on and never off, and its path length bounds the path. `pki.trustanchor.build` writes the list. Offline, fail-closed, bounded — `parseCertdata`, `parseCcadbCsv`, `parseTrustAnchorList`, `anchor` |
+| `pki.trust` | Mozilla and CCADB trust-store ingestion. `parseCertdata` reads the NSS `certdata.txt` object stream and `parseCcadbCsv` the CCADB CSV export, both into one constraint-carrying anchor shape: the per-purpose trust bits, where only `CKT_NSS_TRUSTED_DELEGATOR` grants, and the per-purpose distrust-after dates the bare root list omits. Certificate and trust objects pair by byte-exact issuer and serial rather than adjacency and are cross-checked against the parsed DER, so metadata cannot attach to the wrong root. `anchor()` hands an entry to `pki.path.validate({ trustAnchors, checkPurpose })`, and `anchor(entry, { nameConstraints })` attaches the namespace a root program trusts a root for when that is narrower than the root certificate states, a `{ permitted, excluded }` pair of `{ tag, base }` subtrees that `validate` seeds as the RFC 5280 §6.1.1(h)(i) initial value, intersecting with each certificate's own constraints. `parseTrustAnchorList` reads the IETF's own interchange format for the same thing, an RFC 5914 `TrustAnchorList`, into the same entries, so a list a root program publishes drives `validate` without being mapped by hand. An RFC 5914 anchor's constraints are applied as RFC 5937 §3.2 states, which is that the stricter of the anchor's value and the caller's always wins: its name constraints intersect the caller's permitted subtrees and union its excluded ones, its policy set intersects `userInitialPolicySet`, each of its policy flags may turn the matching `initial*` option on and never off, and its path length bounds the path. `pki.trustanchor.build` writes the list. `systemAnchors` reads the host's own CA bundle into the same entries and names which set it read, `"ca-bundle"` with the path or `"node-bundled"` for the Mozilla set compiled into Node, since the two are not the same trust. A host whose roots are not in a readable PEM file is refused with the command that exports them, and a block that is not a certificate or a certificate the strict reader refuses is listed in `skipped` with its reason. Offline, fail-closed, bounded — `parseCertdata`, `parseCcadbCsv`, `parseTrustAnchorList`, `systemAnchors`, `anchor` |
 | `pki.shbs` | Stateful hash-based signature verification: HSS/LMS (RFC 8554), carried in X.509 by RFC 9802 and in CMS by RFC 9708, profiled by NIST SP 800-208 for CNSA 2.0 firmware signing. `verify` checks an HSS signature, where every level must pass, and `verifyLms` a single-tree LMS, over the raw public-key and signature blobs the parsers already surface. Pure public-input SHA-256 and SHAKE256 hashing, a data-driven typecode registry, and bounds-before-slice reads; a malformed blob throws a typed `ShbsError` while a well-formed but wrong signature returns `false`. Verification only by design, since stateful signing needs atomic one-time-key state that belongs in an HSM. `pki.path.validate` verifies an HSS-signed certificate on its own, so a chain reaching one needs no separate call: the signature covers the whole tbsCertificate rather than a digest of it (RFC 9802 §7.1), and a CertificateList naming the algorithm takes the same route. It is proven against the self-signed certificate RFC 9802 Appendix A publishes — `verify`, `verifyLms` |
 | `pki.hpke` | Hybrid Public Key Encryption (RFC 9180), the encrypt-to-a-public-key primitive behind TLS ECH, MLS, and OHTTP. `setupS` and `setupR` establish a sender or recipient context (KEM encapsulation plus the HKDF key schedule); the context's `seal` and `open` AEAD-encrypt with a sequence-counter nonce, and `export` derives further secrets; the module-level `seal` and `open` are single-shot wrappers. DHKEM (P-256, P-521, X25519, X448) in all four modes, proven against the RFC 9180 Appendix A vectors, and the post-quantum ML-KEM-512/768/1024 KEMs (IANA 0x0040 to 0x0042) in the base and psk modes, proven against the draft-ietf-hpke-pq Appendix A vectors; HKDF-SHA256/SHA384/SHA512 by AES-GCM / ChaCha20Poly1305 / export-only. DHKEM(P-384) has no vector under an HKDF key schedule and fails closed. Pure composition over `node:crypto`; the PQ/T hybrid KEMs are a registry data-row extension once the CFRG combiner draft stabilizes — `suites`, `setupS`, `setupR`, `seal`, `open` |
 | `pki.kem` | Composite ML-KEM key establishment (draft-ietf-lamps-pq-composite-kem), a post-quantum ML-KEM hybridized with a traditional RSA-OAEP, ECDH, X25519, or X448 so the established secret holds if either component is later broken. `encapsulate` turns a recipient's composite `SubjectPublicKeyInfo` into a 256-bit shared secret and a ciphertext; `decapsulate` recovers the same secret from the ciphertext and the composite PKCS#8 private key. Each component KEM runs independently and the two secrets are mixed through a SHA3-256 combiner that binds the traditional ciphertext, the traditional public key, and a per-algorithm label. The twelve algorithms pair ML-KEM-768 and ML-KEM-1024 with RSA-OAEP 2048/3072/4096, ECDH over P-256/P-384/P-521 and brainpoolP256r1/P384r1, X25519, and X448, each verified against the draft Appendix G known-answer vectors; a malformed key or ciphertext, an unsupported algorithm, or a component decapsulation failure throws a typed `KemError` — `encapsulate`, `decapsulate` |
 | `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) 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.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), `csr` (the artifact a CA reads before it issues: an empty subject naming no identity, an empty subject whose subjectAltName is not critical, a request for an extension the issuer determines, a request asking for a CA certificate, a broken signing digest, and a challengePassword traveling with the request; `opts.profile: "cabf-tls"` adds the certificate profile's own commonName-in-SAN, dNSName syntax, SAN-required and key-strength rows, applied to what the request asks for, and they run only when named because a request carries no extKeyUsage. It does not check the request's signature, which is a cryptographic operation `pki.csr.verify` owns), `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/lint.js

@@ -34,6 +34,7 @@ var guard = require("./guard-all");
 var oid = require("./oid");
 var x509 = require("./schema-x509");
 var crlSchema = require("./schema-crl");
+var csrSchema = require("./schema-csr");
 var ocspSchema = require("./schema-ocsp");
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
@@ -1774,6 +1775,163 @@ var RFC5019_OCSP_RULES = [
 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);
 
+/** @internal The extensions an issuer determines, which a request may carry and a CA does not take
+ *  from one. subjectKeyIdentifier and authorityKeyIdentifier are computed from the keys, and the
+ *  three pointers name services the issuer operates. A request for any of them is not a fault in
+ *  the request, so these are reported at notice: the CA simply does not honor them. */
+var CA_DETERMINED_EXTENSIONS = [
+  "authorityKeyIdentifier", "subjectKeyIdentifier", "authorityInfoAccess",
+  "cRLDistributionPoints", "freshestCRL",
+];
+
+/** @internal The signature algorithms a request must not be signed under. A certification request
+ *  is signed by the requester's own key, and the signature is the only evidence the requester
+ *  holds it, so a collision-broken digest removes the one thing the structure proves. */
+var WEAK_CSR_SIG_DIGESTS = ["md2", "md4", "md5", "sha1"];
+
+/** @internal Named outright, because reading the digest out of the algorithm's NAME misses the one
+ *  whose name does not carry it: `shaWithRSAEncryption` is the original SHA, now SHA-0, and it
+ *  spells neither "sha1" nor any other substring above. The set is resolved through the registry
+ *  rather than written as OIDs, so a name that stops resolving fails the round-trip gate in
+ *  oid.test.js rather than silently dropping out of this set. */
+var WEAK_CSR_SIG_OIDS = Object.create(null);
+["shaWithRSAEncryption",
+  "md2WithRSAEncryption", "md4WithRSAEncryption", "md4WithRSAEncryption-pkcs1",
+  "md5WithRSAEncryption", "sha1WithRSAEncryption",
+  "md4WithRSA", "md5WithRSA",
+  "md2WithRSASignature", "md5WithRSASignature", "sha1WithRSASignature",
+  "ecdsaWithSHA1", "dsaWithSha1",
+].forEach(function (n) { var d = oid.byName(n); if (d) WEAK_CSR_SIG_OIDS[d] = n; });
+
+/** @internal RSASSA-PSS carries its digest in the parameters rather than in the algorithm name, so
+ *  the name alone never reads as weak. RFC 4055 sec. 3.1 makes the hashAlgorithm `[0]` field
+ *  DEFAULT sha1, which means ABSENT parameters and an empty parameter SEQUENCE both name SHA-1:
+ *  the shape that looks like it says nothing is the one that says the weakest thing. */
+function _pssDigestName(sigAlg) {
+  if (!sigAlg || sigAlg.oid !== oid.byName("rsassaPss")) return null;
+  var params = sigAlg.parameters;
+  if (params === null || params === undefined) return "sha1";
+  var node;
+  try { node = asn1.decode(params); }
+  // allow:swallow-unverified parameters that do not decode are reported by the value-syntax path
+  catch (_e) { return null; }
+  if (!node || node.tagNumber !== asn1.TAGS.SEQUENCE || !node.children) return null;
+  for (var i = 0; i < node.children.length; i++) {
+    var c = node.children[i];
+    if (c.tagClass !== "context" || c.tagNumber !== 0) continue;
+    var inner = c.children && c.children[0];
+    if (!inner || !inner.children || !inner.children[0]) return null;
+    var dotted;
+    try { dotted = asn1.read.oid(inner.children[0]); }
+    // allow:swallow-unverified a hashAlgorithm that does not read is not a digest this names
+    catch (_e2) { return null; }
+    return oid.name(dotted) || dotted;
+  }
+  return "sha1";
+}
+
+var RFC2986_CSR_RULES = [
+  {
+    id: "lint/rfc2986/subject-empty-no-identity", severity: "error", source: "rfc2986", citation: "RFC 5280 sec. 4.1.2.6",
+    /** @internal Section 4.1.2.6 admits an empty subject only where the subjectAltName carries the
+     * identity instead. A request with neither names nothing to certify, so there is no name for
+     * the issuer to put in the certificate. */
+    message: "a request with an empty subject must request a subjectAltName, or it names nothing to certify",
+    check: function (csr, ctx) {
+      if (_subjectIsNonEmpty(csr)) return null;
+      var san = ctx.decode("subjectAltName");
+      return (san && san.value && san.value.names && san.value.names.length) ? null : true;
+    },
+  },
+  {
+    id: "lint/rfc2986/san-not-critical-empty-subject", severity: "error", source: "rfc2986", citation: "RFC 5280 sec. 4.1.2.6 / 4.2.1.6",
+    /** @internal "If the subject field contains an empty sequence, then the issuing CA MUST
+     * include a subjectAltName extension that is marked as critical." A request whose only
+     * identity is a non-critical SAN asks for a certificate the profile refuses. */
+    message: "where the subject is empty the requested subjectAltName must be critical",
+    check: function (csr, ctx) {
+      if (_subjectIsNonEmpty(csr)) return null;
+      var san = ctx.decode("subjectAltName");
+      if (!san || !san.value || !san.value.names || !san.value.names.length) return null;
+      return san.critical === true ? null : true;
+    },
+  },
+  {
+    id: "lint/rfc2986/ca-determined-extension-requested", severity: "notice", source: "rfc2986", citation: "RFC 5280 sec. 4.2.1.1 / 4.2.1.2 / 4.2.2",
+    message: "the request asks for an extension the issuer determines, which a CA does not take from a request",
+    check: function (csr, ctx) {
+      var out = [];
+      CA_DETERMINED_EXTENSIONS.forEach(function (name) {
+        if (ctx.raw(name)) out.push({ context: { extension: name } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/rfc2986/basic-constraints-ca-requested", severity: "warn", source: "rfc2986", citation: "RFC 5280 sec. 4.2.1.9",
+    /** @internal A subscriber request asking for cA TRUE is the request that turns a subscriber
+     * into an issuer if it is honored, so it is named rather than passed over. It is a warning
+     * and not an error because a CA legitimately issues intermediates from a request. */
+    message: "the request asks for a CA certificate (basicConstraints cA TRUE)",
+    check: function (csr, ctx) {
+      var bc = ctx.decode("basicConstraints");
+      return (bc && bc.value && bc.value.cA === true) ? { context: { pathLenConstraint: bc.value.pathLenConstraint } } : null;
+    },
+  },
+  {
+    id: "lint/rfc2986/weak-signature-algorithm", severity: "error", source: "rfc2986", citation: "RFC 2986 sec. 4.2",
+    message: "the request is signed under a digest no longer fit to carry a proof of possession",
+    check: function (csr) {
+      var alg = csr.signatureAlgorithm;
+      if (alg && WEAK_CSR_SIG_OIDS[alg.oid]) {
+        return { context: { signatureAlgorithm: WEAK_CSR_SIG_OIDS[alg.oid], from: "algorithm" } };
+      }
+      var pss = _pssDigestName(alg);
+      var named = pss !== null ? pss : (alg && alg.name);
+      if (typeof named !== "string") return null;
+      var lower = named.toLowerCase();
+      for (var i = 0; i < WEAK_CSR_SIG_DIGESTS.length; i++) {
+        if (lower.indexOf(WEAK_CSR_SIG_DIGESTS[i]) !== -1) {
+          return { context: { signatureAlgorithm: (alg && alg.name) || (alg && alg.oid),
+            digest: WEAK_CSR_SIG_DIGESTS[i], from: pss !== null ? "parameters" : "algorithm" } };
+        }
+      }
+      return null;
+    },
+  },
+  {
+    id: "lint/rfc2986/extension-request-ambiguous", severity: "error", source: "rfc2986", citation: "RFC 2985 sec. 5.4.2 / X.501 sec. 8.2",
+    /** @internal An attribute type appears once in a SET OF Attributes, and extensionRequest is
+     * SINGLE VALUE besides. Two of them parse when they are in DER order, and which one a reader
+     * takes then depends on how the bytes happened to sort, so one request reads two ways. Every
+     * one of them is linted below, and this row says the request did not ask once. */
+    message: "the request carries more than one extensionRequest attribute, so what it asks for depends on which is read",
+    check: function (csr) {
+      var n = _csrAttributesOf(csr, "extensionRequest").length;
+      return n > 1 ? { context: { count: n } } : null;
+    },
+  },
+  {
+    id: "lint/rfc2986/challenge-password-present", severity: "notice", source: "rfc2986", citation: "RFC 2985 sec. 5.4.1",
+    /** @internal The attribute travels inside the request, so wherever the request is stored or
+     * logged the password is too. Reported so an operator knows it is in the artifact, not
+     * because the structure is wrong. */
+    message: "the request carries a challengePassword, which travels and is stored with it",
+    check: function (csr) { return _csrHasAttribute(csr, "challengePassword") ? true : null; },
+  },
+];
+
+/** @internal The certificate rows that read only the subject, the public key and the requested
+ *  subjectAltName, which a request carries too. They are REUSED rather than restated so the
+ *  pre-issuance answer cannot drift from the post-issuance one: the row, its severity and its
+ *  citation are the certificate profile's own. */
+var CABF_TLS_CSR_RULE_IDS = [
+  "lint/cabf-tls/san-missing",
+  "lint/cabf-tls/cn-not-in-san",
+  "lint/cabf-tls/dnsname-bad-syntax",
+  "lint/cabf-tls/weak-key",
+];
+
 var PROFILES = Object.assign(Object.create(null), {
   "rfc5280": RFC5280_RULES,
   "rfc9881": RFC9881_RULES,
@@ -1783,6 +1941,133 @@ var PROFILES = Object.assign(Object.create(null), {
 });
 var ALL_RULES = RFC5280_RULES.concat(RFC9881_RULES).concat(RFC9909_RULES).concat(RFC9935_RULES).concat(CABF_TLS_RULES);
 
+var CABF_TLS_CSR_RULES = CABF_TLS_RULES.filter(function (r) {
+  return CABF_TLS_CSR_RULE_IDS.indexOf(r.id) !== -1;
+});
+/** @internal RFC 5280 sec. 4.2 fixes each extension's syntax wherever it is carried, and a
+ *  requested extension whose value does not decode is the same fault in a request as in a
+ *  certificate. The certificate's own row reads `extensions` and the request view supplies it, so
+ *  the row is reused rather than restated. Without it a malformed requested value counted as a
+ *  passing check, because the shared decoder returns null and every row that asks by name reads
+ *  that null as absence. */
+var RFC5280_CSR_RULES = RFC5280_RULES.filter(function (r) {
+  return r.id === "lint/rfc5280/extension-undecodable";
+});
+var CSR_STRUCTURAL_RULES = RFC2986_CSR_RULES.concat(RFC5280_CSR_RULES);
+var CSR_PROFILES = Object.assign(Object.create(null), {
+  "rfc2986": CSR_STRUCTURAL_RULES,
+  "cabf-tls": CSR_STRUCTURAL_RULES.concat(CABF_TLS_CSR_RULES),
+});
+var ALL_CSR_RULES = CSR_STRUCTURAL_RULES;
+
+function _subjectIsNonEmpty(csr) {
+  var rdns = csr.subject && csr.subject.rdns;
+  return !!(Array.isArray(rdns) && rdns.length);
+}
+
+function _csrAttributesOf(csr, name) {
+  var dotted = oid.byName(name);
+  var list = csr.attributes || [];
+  var out = [];
+  for (var i = 0; i < list.length; i++) { if (list[i].type === dotted) out.push(list[i]); }
+  return out;
+}
+function _csrHasAttribute(csr, name) { return _csrAttributesOf(csr, name).length > 0; }
+
+/** @internal A request read the way the certificate rows read a certificate: the subject and the
+ *  public key are the request's own, and `extensions` is what the extensionRequest attribute asked
+ *  for. Shaped this way so `_findRaw`, `_decodeOrNull` and the reused CABF rows run unchanged
+ *  against a request rather than each restating how to reach a requested extension. */
+function _csrViewWith(csr, exts) {
+  var view = Object.create(null);
+  view.subject = csr.subject;
+  view.subjectPublicKeyInfo = csr.subjectPublicKeyInfo;
+  view.signatureAlgorithm = csr.signatureAlgorithm;
+  view.attributes = csr.attributes;
+  view.extensions = exts;
+  return view;
+}
+
+/** @internal One view per extensionRequest attribute, rather than one view over all of them
+ *  flattened. A rule that asks for an extension BY NAME reads the first match, so flattening lets
+ *  a basicConstraints of cA FALSE in one attribute hide a cA TRUE in the next: the value that
+ *  decides the answer would be the one that happened to sort first. Each attribute is linted as
+ *  the request it states, and the findings are merged. A request carrying one attribute, which is
+ *  every conforming one, produces exactly one view and the same answer as before. */
+function _csrViews(csr) {
+  var attrs = _csrAttributesOf(csr, "extensionRequest");
+  if (!attrs.length) return [_csrViewWith(csr, [])];
+  return attrs.map(function (attr) {
+    return _csrViewWith(csr, Array.isArray(attr.extensions) ? attr.extensions : []);
+  });
+}
+
+/** @internal The same rule firing on two views of one request is one finding, since the rows that
+ *  do not read an extension see the identical request each time. */
+function _mergeCsrReports(reports) {
+  var findings = [], ran = [], seen = Object.create(null), ranSeen = Object.create(null);
+  reports.forEach(function (r) {
+    r.findings.forEach(function (f) {
+      var key = f.id + "\u0000" + JSON.stringify(f.context === undefined ? null : f.context);
+      if (seen[key]) return;
+      seen[key] = true;
+      findings.push(f);
+    });
+    r.ran.forEach(function (id) { if (!ranSeen[id]) { ranSeen[id] = true; ran.push(id); } });
+  });
+  var counts = Object.assign(Object.create(null), { fatal: 0, error: 0, warn: 0, notice: 0, pass: 0, na: 0, ne: 0 });
+  var failed = Object.create(null), failedCount = 0;
+  findings.forEach(function (f) {
+    counts[f.severity] = (counts[f.severity] || 0) + 1;
+    if (!failed[f.id]) { failed[f.id] = true; failedCount += 1; }
+  });
+  /** @internal A rule that reports twice is still ONE rule that did not pass, which is what
+   * `_runLints` counts, so the distinct failing ids come off the executed ones. Subtracting the
+   * finding count instead understates `pass` the moment any rule reports more than once. */
+  counts.pass = ran.length - failedCount > 0 ? ran.length - failedCount : 0;
+  return { findings: findings, counts: counts, ran: ran };
+}
+
+/** @internal A request carries no extKeyUsage, so nothing in its bytes says it is for TLS. The
+ *  caller names that profile or the TLS rows do not run, which is why `isTlsServerCert` here is
+ *  the caller's statement rather than something read off the artifact. */
+function _makeCsrCtx(view, profile) {
+  var explicitTls = profile === "cabf-tls";
+  return {
+    profile: profile,
+    explicitTlsProfile: explicitTls,
+    isTlsServerCert: explicitTls,
+    decode: function (name) { return _decodeOrNull(view, name); },
+    raw: function (name) { return _findRaw(view, name); },
+  };
+}
+
+/** @internal The kind-checked door the other lint verbs use, rather than a property test of our
+ *  own: a parsed certificate carries a subjectPublicKeyInfo too, so a shape test admits one as a
+ *  request and then reads its extensions from an extensionRequest attribute it does not have,
+ *  reporting on a request that was never made. */
+function _derivedCsr(o) {
+  if (!o || typeof o !== "object" || guard.bytes.isByteSource(o)) return null;
+  // allow:swallow-unverified an object the guard refuses is not a parsed request, and the byte paths below answer for it
+  try { return guard.parsed.acceptDerived(o, "csr", csrSchema.parse, _cfg, "lint/bad-input", "the certification request"); }
+  catch (_e) { return null; }
+}
+
+function _ingestCsr(input) {
+  var derived = _derivedCsr(input);
+  if (derived) return { csr: derived };
+  var der;
+  if (Buffer.isBuffer(input)) der = input;
+  else if (typeof input === "string") {
+    try { der = csrSchema.pemDecode(input); }
+    catch (e) { return { fatal: { id: "lint/unparseable", severity: "fatal", source: "engine", citation: "pki.lint", message: "input is not a decodable PEM/DER certification request", context: { code: e.code } } }; }
+  } else {
+    throw _cfg("lint/bad-input", "pki.lint.csr input must be a parsed certification request, a DER Buffer, or a PEM string");
+  }
+  try { return { csr: csrSchema.parse(der) }; }
+  catch (e) { return { fatal: { id: "lint/unparseable", severity: "fatal", source: "engine", citation: "RFC 2986", message: "input is not a well-formed PKCS#10 certification request", context: { code: e.code } } }; }
+}
+
 function _selectRules(profile) {
   if (profile == null || profile === "all" || profile === "default") return ALL_RULES;
   if (!PROFILES[profile]) {
@@ -1929,6 +2214,87 @@ function _ingestCrl(input) {
  *   report.worst;                                       // -> "error", for the missing AKI
  *   report.findings.map(function (f) { return f.id; }); // -> ["lint/rfc5280-crl/aki-missing"]
  */
+/**
+ * @primitive  pki.lint.csr
+ * @signature  pki.lint.csr(pem | der | parsed, opts?) -> LintReport
+ * @since      0.8.16
+ * @status     stable
+ * @spec       RFC 2986, RFC 2985 sec. 5.4, RFC 5280 sec. 4.1.2.6, CA/Browser Forum TLS BR
+ * @related    pki.lint.certificate, pki.csr.verify, pki.schema.csr.parse, pki.csr.sign
+ *
+ * Lint a PKCS#10 certification request, which is the artifact a CA reads before it issues. `input`
+ * is a PEM string, a DER `Buffer`, or an already-parsed `pki.schema.csr` 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 request produce a single `fatal` finding `lint/unparseable`
+ * carrying the strict parser's own code.
+ *
+ * The rows cover what the request asks for: an empty subject and whether a subjectAltName carries
+ * the identity in its place, the extensions an issuer determines rather than takes from a request,
+ * a request asking for a CA certificate, the digest the request is signed under, and a
+ * challengePassword traveling inside it.
+ *
+ * This does not check the request's signature. That signature is the requester's proof that it
+ * holds the private key, verifying it is a cryptographic operation rather than a profile question,
+ * and `pki.csr.verify` is the verb for it. A CA runs both.
+ *
+ * The CA/Browser Forum rows run only under `opts.profile: "cabf-tls"`. A request carries no
+ * extKeyUsage, so nothing in its bytes says it is for TLS, and the caller states that. Those rows
+ * are the certificate profile's own, applied to what the request asks for, so the answer before
+ * issuance is the answer after it.
+ *
+ * Five shapes never appear here because the strict parser refuses them first and a rule for them
+ * could not fire. A version other than 0 (RFC 2986 sec. 4.1), a challengePassword or
+ * extensionRequest attribute carrying more than one value, an extensionRequest carrying no
+ * extensions (RFC 2985 sec. 5.4), the same extension OID twice inside one, and attributes out of
+ * DER order each arrive as `lint/unparseable` carrying the parser's own code. A SECOND
+ * extensionRequest attribute does parse, where the two sort in DER order, and is reported by
+ * `lint/rfc2986/extension-request-ambiguous`; every one of them is read, so nothing a later
+ * attribute asks for escapes the rows below.
+ *
+ * @opts  profile   `"rfc2986"` for the structural rows alone, or `"cabf-tls"` to add the TLS rows
+ *                  (default runs the structural rows). A certificate, CRL or OCSP profile name is
+ *                  refused rather than run against a request.
+ * @opts  severity  Suppress findings below this floor (default `"notice"`). `counts` and `worst`
+ *                  always reflect the complete, unfiltered result.
+ * @example
+ *   var pair = await pki.key.generate("Ed25519");
+ *   var der = await pki.csr.sign({ subject: [{ commonName: "example.com" }],
+ *     subjectPublicKey: await pki.key.export(pair.publicKey) },
+ *     { key: await pki.key.export(pair.privateKey) });
+ *   var report = pki.lint.csr(der, { profile: "cabf-tls" });
+ *   report.findings.map(function (f) { return f.id; }); // -> ["lint/cabf-tls/san-missing"]
+ */
+function csr(input, opts) {
+  opts = guard.identifier.optionsObject(opts, _cfg, "lint/bad-input", "pki.lint options");
+  guard.identifier.assertKnownKeys(opts, _CRL_OPTS, _cfg, "lint/bad-input",
+    "pki.lint.csr 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_CSR_RULES;
+  else if (CSR_PROFILES[profile]) rules_ = CSR_PROFILES[profile];
+  else if (CRL_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a CRL profile; lint a CRL with pki.lint.crl");
+  else if (OCSP_PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is an OCSP profile; lint a response with pki.lint.ocsp");
+  else if (PROFILES[profile]) throw _cfg("lint/unknown-profile", "\"" + profile + "\" is a certificate profile; lint a certificate with pki.lint.certificate");
+  else throw _cfg("lint/unknown-profile", "unknown certification-request lint profile \"" + profile + "\" (known: " + Object.keys(CSR_PROFILES).join(", ") + ")");
+
+  var ingested = _ingestCsr(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 {
+    report = _mergeCsrReports(_csrViews(ingested.csr).map(function (view) {
+      return _runLints(rules_, view, _makeCsrCtx(view, profile));
+    }));
+  }
+  report.worst = _worst(report.findings);
+  report.findings = _applyThreshold(report, opts.severity);
+  return report;
+}
+
 function crl(input, opts) {
   opts = guard.identifier.optionsObject(opts, _cfg, "lint/bad-input", "pki.lint options");
   guard.identifier.assertKnownKeys(opts, _CRL_OPTS, _cfg, "lint/bad-input",
@@ -2074,23 +2440,67 @@ function ocsp(input, opts) {
 
 /**
  * @primitive  pki.lint.rules
- * @signature  pki.lint.rules(profile?) -> [{id, severity, source, citation}]
+ * @signature  pki.lint.rules(profile?, artifact?) -> [{id, severity, source, citation}]
  * @since      0.2.10
  * @status     stable
  * @spec       RFC 5280, CA/Browser Forum TLS BR
  *
  * Enumerate the rule registry (all rules, or one profile's). Each entry exposes its
  * stable `id`, `severity`, `source`, and spec-clause `citation` for documentation and
- * corpus tooling.
+ * corpus tooling. Each id appears once, including where two artifacts run the same rule.
+ *
+ * `artifact` says which verb's reading of a profile name to return, and is needed because
+ * `"cabf-tls"` names a set for both `pki.lint.certificate` and `pki.lint.csr` and the two are not
+ * the same rows: a request has no extKeyUsage and no validity period, and carries structural rows
+ * a certificate does not. It is `"certificate"`, `"csr"`, `"crl"` or `"ocsp"`, and defaults to the
+ * artifact that first claims the name, which is the certificate for `"cabf-tls"`.
+ *
  * @example
- *   pki.lint.rules("rfc5280").length;   // -> a positive count
+ *   pki.lint.rules("rfc5280").length;              // -> a positive count
+ *   pki.lint.rules("cabf-tls", "csr").length;      // -> the rows pki.lint.csr runs under it
  */
-function rules(profile) {
-  var set = profile == null
-    ? 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 }; });
+/** @internal Prototype-less, because `artifact` is the caller's string and a computed lookup on a
+ *  literal would answer for "constructor" and the rest of Object.prototype. */
+var BY_ARTIFACT = Object.assign(Object.create(null), {
+  certificate: PROFILES, csr: CSR_PROFILES, crl: CRL_PROFILES, ocsp: OCSP_PROFILES,
+});
+
+function rules(profile, artifact) {
+  if (artifact != null && !Object.prototype.hasOwnProperty.call(BY_ARTIFACT, artifact)) {
+    throw _cfg("lint/bad-input", "unknown lint artifact \"" + artifact +
+      "\" (known: " + Object.keys(BY_ARTIFACT).join(", ") + ")");
+  }
+  var set;
+  if (profile == null && artifact != null) {
+    /** @internal An artifact without a profile asks what that VERB can run, which is the union of
+     * its own profiles. Returning the whole registry would answer with a certificate's validity
+     * rows and the CRL and OCSP sets, none of which a request or a response is ever held to. */
+    set = [];
+    Object.keys(BY_ARTIFACT[artifact]).forEach(function (name) {
+      BY_ARTIFACT[artifact][name].forEach(function (r) { set.push(r); });
+    });
+  } else if (profile == null) {
+    set = ALL_RULES.concat(ALL_CRL_RULES).concat(ALL_OCSP_RULES).concat(ALL_CSR_RULES);
+  } else if (artifact != null) {
+    set = BY_ARTIFACT[artifact][profile];
+    if (!set) {
+      throw _cfg("lint/unknown-profile", "\"" + profile + "\" is not a " + artifact +
+        " lint profile (known: " + Object.keys(BY_ARTIFACT[artifact]).join(", ") + ")");
+    }
+  } else {
+    set = PROFILES[profile] || CRL_PROFILES[profile] || OCSP_PROFILES[profile] || CSR_PROFILES[profile];
+    if (!set) throw _cfg("lint/unknown-profile", "unknown lint profile \"" + profile + "\"");
+  }
+  /** @internal One row per id: a rule reused across artifacts, like the RFC 5280 sec. 4.2
+   * extension-syntax row a request and a certificate both run, is one rule with one id, and
+   * tooling that counts or registers from this list would otherwise process it twice. */
+  var seen = Object.create(null), out = [];
+  set.forEach(function (r) {
+    if (seen[r.id]) return;
+    seen[r.id] = true;
+    out.push({ id: r.id, severity: r.severity, source: r.source, citation: r.citation });
+  });
+  return out;
 }
 
 /**
@@ -2104,10 +2514,18 @@ function rules(profile) {
  * @example
  *   pki.lint.profiles();   // -> ["rfc5280", "rfc9881", "rfc9909", "rfc9935", "cabf-tls", "rfc5280-crl", "rfc6960", "rfc5019"]
  */
-function profiles() { return Object.keys(PROFILES).concat(Object.keys(CRL_PROFILES)).concat(Object.keys(OCSP_PROFILES)); }
+/** @internal `cabf-tls` names the certificate profile in this list and is not repeated for the
+ *  request form: `pki.lint.csr` takes the same name and runs those rows against what a request
+ *  asks for, so one name means one set of requirements whichever artifact carries it. */
+function profiles() {
+  var out = Object.keys(PROFILES).concat(Object.keys(CRL_PROFILES)).concat(Object.keys(OCSP_PROFILES));
+  Object.keys(CSR_PROFILES).forEach(function (name) { if (out.indexOf(name) === -1) out.push(name); });
+  return out;
+}
 
 module.exports = {
   certificate: certificate,
+  csr: csr,
   crl: crl,
   ocsp: ocsp,
   rules: rules,

package/lib/oid.js

@@ -165,8 +165,19 @@ var FAMILIES = Object.assign(Object.create(null), {
     buildConfigURI: 18, buildConfigDigest: 19, buildTrigger: 20,
     runInvocationURI: 21, sourceRepositoryVisibilityAtSigning: 22 } },
 
+  /** @internal md5WithRSAEncryption and sha1WithRSAEncryption are registered so the toolkit can
+   *  NAME them, not so it can use them. Nothing signs or verifies from this registry: the signing
+   *  and verifying paths carry their own name-keyed tables, and neither has a row for these. An
+   *  unregistered OID reads back as an undefined name, which left a linter unable to say what a
+   *  request from another implementation was signed under. */
   rsa: { base: [1, 2, 840, 113549, 1, 1], of: {
-    rsaEncryption: 1, rsaesOaep: 7, mgf1: 8, pSpecified: 9, rsassaPss: 10,
+    /** @internal PKCS#1's MD4 signature carries the arc-qualified name because the OIW arc already
+     *  holds the plain `md4WithRSAEncryption` for 1.3.14.3.2.4. The registry is two-way and a name
+     *  registered twice repoints every lookup of it, so two standards using one name for two OIDs
+     *  are told apart here rather than silently sharing an entry. */
+    rsaEncryption: 1, md2WithRSAEncryption: 2, "md4WithRSAEncryption-pkcs1": 3,
+    md5WithRSAEncryption: 4, sha1WithRSAEncryption: 5,
+    rsaesOaep: 7, mgf1: 8, pSpecified: 9, rsassaPss: 10,
     sha256WithRSAEncryption: 11,
     sha384WithRSAEncryption: 12, sha512WithRSAEncryption: 13 } },
 
@@ -271,8 +282,14 @@ var FAMILIES = Object.assign(Object.create(null), {
 
   ansiX962: { base: [1, 2, 840, 10045], of: {
     ecPublicKey: [2, 1], prime192v1: [3, 1, 1], prime256v1: [3, 1, 7],
+    ecdsaWithSHA1: [4, 1],
     ecdsaWithSHA256: [4, 3, 2], ecdsaWithSHA384: [4, 3, 3], ecdsaWithSHA512: [4, 3, 4] } },
 
+  /** @internal X9.57 DSA, registered for naming alone. The toolkit neither signs nor verifies DSA,
+   *  and dsaWithSha1 is here so a request or certificate carrying it reads back with a name rather
+   *  than a bare dotted string, which is what a linter needs to say what it refused. */
+  x957: { base: [1, 2, 840, 10040, 4], of: { dsa: 1, dsaWithSha1: 3 } },
+
   secg: { base: [1, 3, 132, 0], of: {
     sect163k1: 1, sect163r1: 2, secp256k1: 10, sect163r2: 15, sect283k1: 16, sect283r1: 17,
     sect233k1: 26, sect233r1: 27, secp192k1: 31, secp224k1: 32, secp224r1: 33,

package/lib/trust.js

@@ -47,6 +47,8 @@ var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var x509 = require("./schema-x509");
 var pkix = require("./schema-pkix");
 var oid = require("./oid");
+var nodeFs = require("fs");
+var nodeTls = require("tls");
 var trustanchorSchema = require("./schema-trustanchor");
 
 var TrustError = errors.TrustError;
@@ -1130,9 +1132,317 @@ function _entryFromAnchor(a, i) {
   return entry;
 }
 
+/** @internal The bundle paths a Unix host keeps its CA set in, in the order a reader should try
+ *  them. Each is a concatenated PEM file the distribution maintains. macOS and Windows keep theirs
+ *  in a binary keychain and a registry-backed store, so neither has a path here. */
+var _BUNDLE_PATHS = [
+  "/etc/ssl/certs/ca-certificates.crt",
+  "/etc/pki/tls/certs/ca-bundle.crt",
+  "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",
+  "/etc/ssl/ca-bundle.pem",
+  "/etc/ssl/cert.pem",
+  "/usr/local/share/certs/ca-root-nss.crt",
+];
+
+var _SYSTEM_ANCHOR_OPTS = intrinsic.assign(intrinsic.create(null), {
+  path: 1, allowNodeBundle: 1, maxBytes: 1,
+});
+
+/** @internal What an operator runs to produce a bundle this verb can read, per platform. Named in
+ *  the refusal, because the alternative an operator reaches for otherwise is Node's compiled-in
+ *  set, which is not what their host trusts. */
+function _exportHint() {
+  if (process.platform === "darwin") {
+    return "export the host's roots with: security find-certificate -a -p " +
+      "/System/Library/Keychains/SystemRootCertificates.keychain > roots.pem";
+  }
+  if (process.platform === "win32") {
+    return "export the host's roots with: certutil -store ROOT";
+  }
+  return "point opts.path at the CA bundle this host keeps";
+}
+
+/**
+ * @primitive  pki.trust.discoversBundles
+ * @signature  pki.trust.discoversBundles(platform) -> boolean
+ * @since      0.8.15
+ * @status     stable
+ * @spec       RFC 5280
+ * @defends    trust-store-misattribution (CWE-345)
+ * @related    pki.trust.systemAnchors
+ *
+ * Whether `systemAnchors` searches for a CA bundle on this platform. A Unix host's bundle IS the
+ * set its TLS stack trusts. macOS keeps its trust decisions in Keychain and Windows in a
+ * registry-backed store, and on macOS `/etc/ssl/cert.pem` can exist as OpenSSL's own copy, which
+ * is not the host's trust and omits both locally installed roots and Keychain overrides. Reporting
+ * that file as the host's anchors is the misattribution this verb exists to prevent, so those
+ * platforms are refused rather than searched. `opts.path` still reads an exported bundle anywhere.
+ *
+ * @example
+ *   pki.trust.discoversBundles("linux");  // -> true
+ *   pki.trust.discoversBundles("darwin"); // -> false
+ */
+function discoversBundles(platform) {
+  if (typeof platform !== "string" || platform.length === 0) {
+    throw E("trust/bad-input", "discoversBundles takes a process.platform string");
+  }
+  return platform !== "darwin" && platform !== "win32";
+}
+
+/** @internal Reads at most `maxBytes + 1` so the cap bounds what is ALLOCATED rather than being
+ *  checked after an unbounded read: a file far above the cap must not reach memory first. */
+function _readBundleText(chosen, maxBytes) {
+  var fd = null, raw, read;
+  try {
+    fd = nodeFs.openSync(chosen, "r");
+    var buf = intrinsic.bufferAlloc(maxBytes + 1);
+    /** @internal readSync may return fewer bytes than asked for, so the prefix of one call is not
+     * the file. Taking it as the whole bundle would drop the roots below the break with nothing
+     * reported, and would let a file above the cap pass the check underneath it. */
+    read = 0;
+    for (;;) {
+      var got = nodeFs.readSync(fd, buf, read, (maxBytes + 1) - read, read);
+      if (got === 0) break;
+      read += got;
+      if (read >= maxBytes + 1) break;
+    }
+    raw = buf.subarray(0, read);
+  } catch (e) {
+    throw E("trust/no-readable-store", "no CA bundle could be read at " + guard.text.showValue(chosen) +
+      "; " + _exportHint() + ", or pass opts.allowNodeBundle to use the Mozilla set compiled into " +
+      "Node, which is NOT what this host trusts", e);
+  } finally {
+    if (fd !== null) {
+      try { nodeFs.closeSync(fd); }
+      // allow:swallow-unverified the descriptor is released on a best-effort basis
+      catch (_e) { void 0; }
+    }
+  }
+  if (read > maxBytes) {
+    throw E("trust/too-large", "the CA bundle at " + guard.text.showValue(chosen) +
+      " is larger than the " + maxBytes + "-byte cap this read admits");
+  }
+  return raw;
+}
+
+/**
+ * @primitive  pki.trust.systemAnchors
+ * @signature  pki.trust.systemAnchors(opts?) -> { anchors, source, path, skipped }
+ * @since      0.8.15
+ * @status     stable
+ * @spec       RFC 7468 (PEM), RFC 5280
+ * @defends    trust-store-misattribution (CWE-345), trust-store-parser-DoS (CWE-770)
+ * @related    pki.trust.parseCertdata, pki.trust.parseCcadbCsv, pki.trust.anchor, pki.path.validate
+ *
+ * Read the host's CA bundle into the trust anchors `pki.path.validate` consumes. `source` names
+ * which set was read: `"ca-bundle"` for a file on this host, with `path` naming it, or
+ * `"node-bundled"` for the Mozilla set compiled into Node, whose `path` is `null`. A block the
+ * bundle carries that is not a certificate is listed in `skipped` with the label that named it,
+ * rather than dropped.
+ *
+ * A host whose roots are not in a readable PEM file is refused, and the refusal names the command
+ * that exports them. macOS keeps its roots in a binary keychain and Windows in a registry-backed
+ * store, and reading either means running another program, which this toolkit does not do. Falling
+ * back to Node's set instead would report anchors the host does not use, so that takes the
+ * explicit `opts.allowNodeBundle`.
+ *
+ * @opts
+ *   - `path` -- read this file instead of searching the per-platform list.
+ *   - `allowNodeBundle` -- return Node's compiled-in set when no bundle can be read.
+ *   - `maxBytes` -- cap the bundle read (default `C.LIMITS.TRUST_MAX_BYTES`).
+ *
+ * @example
+ *   // Read the host's bundle where there is one, and say so when there is not. Check `source`
+ *   // before trusting the answer: "node-bundled" is Node's compiled-in set, not this machine's.
+ *   var store = pki.trust.systemAnchors({ allowNodeBundle: true });
+ *   console.log(store.source);            // -> "ca-bundle" on a Unix host, else "node-bundled"
+ *   console.log(store.anchors.length > 0); // -> true
+ *   console.log(store.skipped.length >= 0); // -> true (entries named, never dropped silently)
+ */
+function systemAnchors(opts) {
+  opts = opts || {};
+  guard.identifier.assertPlainRecord(opts, E, "trust/bad-input", "systemAnchors opts");
+  guard.identifier.assertKnownKeys(opts, _SYSTEM_ANCHOR_OPTS, E, "trust/bad-input",
+    "unknown systemAnchors option ");
+  var maxBytes = guard.limits.cap(opts.maxBytes, "systemAnchors: opts.maxBytes",
+    LIMITS.TRUST_MAX_BYTES, { E: E, code: "trust/bad-input", min: 1, max: LIMITS.TRUST_MAX_BYTES });
+
+  var chosen = null;
+  if (opts.path !== undefined) {
+    if (typeof opts.path !== "string" || opts.path.length === 0) {
+      throw E("trust/bad-input", "systemAnchors: opts.path must be a non-empty string");
+    }
+    chosen = opts.path;
+  }
+
+  var text = null;
+  if (chosen !== null) {
+    /** @internal `allowNodeBundle` says what to do when there is NO readable bundle, so an absent
+     * file falls back to Node's set under it. A bundle that EXISTS and breaks the cap does not:
+     * the caller asked about that file, and a resource refusal must never quietly swap the trust
+     * set a validation runs against for a different one. */
+    try { text = _readBundleText(chosen, maxBytes); }
+    catch (e) {
+      if (opts.allowNodeBundle !== true || !e || e.code !== "trust/no-readable-store") throw e;
+      text = null;
+      chosen = null;
+    }
+  } else if (discoversBundles(process.platform)) {
+    for (var i = 0; i < _BUNDLE_PATHS.length && text === null; i++) {
+      /** @internal Readability is established by READING, not by a stat: a candidate that exists
+       * but cannot be opened must not stop the search and strand a readable one below it. */
+      try { text = _readBundleText(_BUNDLE_PATHS[i], maxBytes); chosen = _BUNDLE_PATHS[i]; }
+      catch (e) {
+        if (e && e.code === "trust/too-large") throw e;
+        // allow:swallow-unverified a candidate this host cannot read is not this host's bundle
+        text = null;
+      }
+    }
+  }
+
+  if (text === null) {
+    if (opts.allowNodeBundle !== true) {
+      throw E("trust/no-readable-store", "this host keeps no CA bundle this toolkit can read" +
+        (chosen === null ? "" : " at " + guard.text.showValue(chosen)) + "; " + _exportHint() +
+        ", or pass opts.allowNodeBundle to use the Mozilla set compiled into Node, which is NOT " +
+        "what this host trusts");
+    }
+    return _anchorsFromPems(nodeTls.rootCertificates, "node-bundled", null);
+  }
+  return _anchorsFromBundle(text, chosen);
+}
+
+/** @internal A line that reads as a BEGIN boundary but does not start one, because RFC 7468 sec. 2
+ *  puts the boundary at the start of a line and this one is indented or trailed. The decoder is
+ *  right to pass over it as explanatory text, and in a trust bundle that is an anchor the operator
+ *  believes they installed and does not have. Reported with the offset, never a throw: the file is
+ *  readable and the other roots in it are usable. */
+/** @internal The bytes of "-----BEGIN ", held as codes because this directory scans by character
+ *  code rather than by pattern. */
+var _BEGIN_MARK = [0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x42, 0x45, 0x47, 0x49, 0x4e, 0x20];
+
+function _reportUnusableBoundaries(bytes, rows, skipped) {
+  var used = intrinsic.create(null);
+  for (var r = 0; r < rows.length; r++) used[rows[r].offset] = true;
+  var lineStart = 0;
+  for (var i = 0; i <= bytes.length; i++) {
+    if (i !== bytes.length && bytes[i] !== 0x0a) continue;
+    var at = lineStart;
+    while (at < i && (bytes[at] === 0x20 || bytes[at] === 0x09)) at += 1;
+    var indented = at > lineStart;
+    var matches = indented && at + _BEGIN_MARK.length <= i;
+    for (var m = 0; matches && m < _BEGIN_MARK.length; m++) {
+      if (bytes[at + m] !== _BEGIN_MARK[m]) matches = false;
+    }
+    if (matches && used[at] !== true) {
+      guard.list.append(skipped, {
+        index: null, offset: at, label: null,
+        reason: "pem/unusable-boundary: a BEGIN boundary at byte " + at + " does not start its " +
+          "line, so RFC 7468 sec. 2 reads it as text and the object it opens is not decoded",
+      });
+    }
+    lineStart = i + 1;
+  }
+}
+
+/** @internal Every certificate block becomes an anchor and every other block is reported, because
+ *  a bundle an operator assembled by hand is exactly where a key or a CRL ends up, and a reader
+ *  that drops one silently leaves them believing it was read. */
+function _anchorsFromBundle(text, chosen) {
+  var rows;
+  try { rows = pkix.pemDecodeBundle(text, {}, errors.PemError); }
+  catch (e) {
+    if (e && e.code === "pem/no-block") {
+      throw E("trust/no-anchors", "the CA bundle at " + guard.text.showValue(chosen) +
+        " carries no PEM block, so it names no trust anchor", e);
+    }
+    throw E("trust/bad-bundle", "the CA bundle at " + guard.text.showValue(chosen) +
+      " is not readable as PEM: " + guard.text.describeThrown(e), e);
+  }
+  var anchors = [], skipped = [];
+  _reportUnusableBoundaries(text, rows, skipped);
+  for (var i = 0; i < rows.length; i++) {
+    var row = rows[i];
+    if (row.label === "TRUSTED CERTIFICATE") {
+      /** @internal OpenSSL's TRUSTED CERTIFICATE is a Certificate followed by an X509_CERT_AUX
+       * carrying the purposes the operator trusted it FOR. Reading the leading certificate and
+       * dropping the aux would hand back a root restricted to one purpose as an unrestricted
+       * anchor, which is a widening, so the block is reported until the aux is read. */
+      guard.list.append(skipped, {
+        index: row.index, offset: row.offset, label: row.label,
+        reason: "trust/aux-not-read: an OpenSSL trusted certificate carries the purposes it is " +
+          "trusted for in a trailing X509_CERT_AUX this reader does not decode, and ingesting it " +
+          "without them would widen the trust it states; convert it with " +
+          "`openssl x509 -in <file> -out <file>.pem` and pass the result",
+      });
+      continue;
+    }
+    if (row.label !== "CERTIFICATE") {
+      guard.list.append(skipped, {
+        index: row.index, offset: row.offset, label: row.label,
+        reason: "trust/not-a-certificate-block: a " + guard.text.showValue(row.label) +
+          " block names no trust anchor",
+      });
+      continue;
+    }
+    var cert = null, why = null;
+    try { cert = x509.parse(row.der); }
+    catch (e) { why = (e && e.code ? e.code : "trust/not-a-certificate") + ": " + guard.text.describeThrown(e); }
+    if (cert === null) {
+      /** @internal Reported, not thrown. A host CA bundle is distribution-managed and real ones
+       * carry certificates this toolkit refuses: the Mozilla set Node ships has a root encoding
+       * pre-2050 dates as GeneralizedTime against the RFC 5280 sec. 4.1.2.5 MUST. Refusing the
+       * whole file would leave the operator with no anchors over a root they do not control,
+       * and relaxing the reader to admit it would weaken every other caller. The entry is named
+       * with the reason instead, so a missing anchor is visible rather than silent. */
+      guard.list.append(skipped, { index: row.index, offset: row.offset, label: row.label, reason: why });
+      continue;
+    }
+    guard.list.append(anchors, _mkAnchor(cert, {
+      distrustAfter: {}, purposes: null, label: null, mozillaCaPolicy: false,
+    }));
+  }
+  if (anchors.length === 0) {
+    throw E("trust/no-anchors", "the CA bundle at " + guard.text.showValue(chosen) +
+      " carries no certificate, so it names no trust anchor");
+  }
+  return _systemResult(anchors, "ca-bundle", chosen, skipped);
+}
+
+function _anchorsFromPems(pems, source, chosen) {
+  var anchors = [], skipped = [];
+  for (var i = 0; i < pems.length; i++) {
+    var cert = null, why = null;
+    try { cert = x509.parse(x509.pemDecode(pems[i], "CERTIFICATE")); }
+    catch (e) { why = (e && e.code ? e.code : "trust/not-a-certificate") + ": " + guard.text.describeThrown(e); }
+    if (cert === null) {
+      guard.list.append(skipped, { index: i, offset: null, label: "CERTIFICATE", reason: why });
+      continue;
+    }
+    guard.list.append(anchors, _mkAnchor(cert, {
+      distrustAfter: {}, purposes: null, label: null, mozillaCaPolicy: false,
+    }));
+  }
+  if (anchors.length === 0) throw E("trust/no-anchors", "the " + source + " set carries no certificate");
+  return _systemResult(anchors, source, chosen, skipped);
+}
+
+/** @internal Defined rather than assigned, and a fresh list each call: the caller owns what it is
+ *  handed, so emptying it must not change what the next call returns. */
+function _systemResult(anchors, source, chosen, skipped) {
+  var out = intrinsic.create(null);
+  guard.verdict.set(out, "anchors", anchors);
+  guard.verdict.set(out, "source", source);
+  guard.verdict.set(out, "path", chosen);
+  guard.verdict.set(out, "skipped", skipped);
+  return out;
+}
+
 module.exports = {
   parseCertdata: parseCertdata,
   parseCcadbCsv: parseCcadbCsv,
   parseTrustAnchorList: parseTrustAnchorList,
+  systemAnchors: systemAnchors,
+  discoversBundles: discoversBundles,
   anchor: anchor,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.8.14",
+  "version": "0.8.16",
   "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:bdd8bb52-b998-41cd-a57e-6c673739a7a6",
+  "serialNumber": "urn:uuid:770a6573-9a63-4951-bf37-d9999705b708",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-24T03:02:34.975Z",
+    "timestamp": "2026-09-24T05:26:27.977Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.8.14",
+      "bom-ref": "@blamejs/pki@0.8.16",
       "type": "application",
       "name": "pki",
-      "version": "0.8.14",
+      "version": "0.8.16",
       "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.8.14",
+      "purl": "pkg:npm/%40blamejs/pki@0.8.16",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.8.14",
+      "ref": "@blamejs/pki@0.8.16",
       "dependsOn": []
     }
   ]