@blamejs/pki 0.8.19 → 0.8.21

package/CHANGELOG.md

@@ -4,6 +4,42 @@ 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.21 — 2026-09-24
+
+A qualified certificate is linted against the statements it carries, not just their syntax.
+
+### Added
+
+- `pki.lint.certificate(der, { profile: "etsi-qc" })` runs the ETSI EN 319 412-5 v2.4.1 profile, and the rows reach a certificate unprompted because carrying the extension is what the clause governs.
+- The qcStatements extension must not be marked critical, and a certificate names one and only one of the three purposes the clause defines: electronic signature, electronic seal and web site authentication. The clause limits the certificate, so the purposes are counted across every QcType statement it carries and two statements naming one each break it as surely as one naming two. The syntax admits identifiers beyond those three, so one of them is not a second purpose and is not counted.
+- A QcPDS statement must provide an https URL. The clause asks for one as a minimum, so a plain URL beside a secure one satisfies it. Under the requirements an EU qualified certificate carries, that statement must also name a document in English and must not name more than one per language.
+- The semantics identifiers of ETSI EN 319 412-1 v1.5.1 are read, and a subject attribute they govern is held to the structure they require: a three-character identity type reference, a two-character country code, a hyphen-minus and an identifier. A natural person identifier governs the subject serialNumber and admits PAS, IDC, PNO, TAX and TIN; a legal person identifier governs the subject organizationIdentifier and admits VAT, NTR, PSD and LEI. An LEI value must carry the country code XG. A TAX reference is reported as deprecated, which the standard states at a lower strength than the rest, so the finding is a warning.
+- Either identifier may instead name a locally defined reference, two characters and a colon, and one of those requires a nameRegistrationAuthorities element carrying a uniformResourceIdentifier, since that is what makes the local scheme resolvable.
+
+### Changed
+
+- The four semantics identifiers of ETSI EN 319 412-1 section 5.1.2 resolve through `pki.oid`, and a decoded SemanticsInformation carries `semanticsIdentifierName` beside the identifier, the way a QcType carries `typeNames` and a QcIdentMethod `methodNames`. It is null for an identifier the registry does not name.
+- Every statement of a kind is graded, not the first of that kind. RFC 3739 section 3.2.6 puts no cardinality on QCStatements, so a certificate may carry two disclosure statements or two semantics statements, and the order they sit in the extension decides nothing.
+
+## v0.8.20 — 2026-09-24
+
+An extended validation code signing certificate is held to the subject its own section requires.
+
+### Added
+
+- The subject fields both arms share (section 7.1.4.2.2): a `commonName` is required, a `domainComponent` is prohibited, and a subject attribute carrying only the metadata characters the clause names, a full stop, a hyphen and a space, is reported. An empty value states the same absence and is read the same way.
+- The subject fields a code signing certificate must carry (sections 7.1.4.2.3 and 7.1.4.2.4): an `organizationName`, a `countryName` that is a two-letter code, and at least one of `localityName` and `stateOrProvinceName`, since each of those two is required exactly when the other is absent. Section 7.1.4.2.4 carries the address fields onto an extended validation certificate, so both arms answer for them.
+- The subject fields an extended validation certificate adds (section 7.1.4.2.4): a `businessCategory` that is one of the four strings the clause names, a `jurisdictionCountryName`, and a `serialNumber`. The clause also bounds the jurisdiction fields against the level the incorporating or registration agency operates at, and requires the state or province at the locality level only where the state or province regulates registration there. A certificate carries neither fact, and a country with a locality and no state is conformant for such an agency, so no row grades the relationship and a valid certificate is not failed for it.
+- The three reserved policy identifiers are read apart rather than together, so `2.23.140.1.3` selects the extended validation arm and `2.23.140.1.4.1` the ordinary one. The extension rules of section 7.1.2.3 ask the same question of both, and the subject rules do not.
+
+### Changed
+
+- A subject attribute is read through one reader shared by every rule that asks for one, flattened across the relative distinguished names, because a distinguished name says the same thing whether it carries one multi-valued element or several single-valued ones.
+
+### Fixed
+
+- Which rules a certificate answers for no longer depends on the order its policies sit in. A certificate asserting two reserved identifiers claims both, and the profile read only the first, so one asserting the ordinary code signing identifier ahead of the extended validation one escaped every extended validation rule while the same certificate with those two reversed did not. Section 7.1.6.4 reports more than one identifier, but only for a certificate issued on or after 15 September 2026, so nothing else caught it. A certificate claiming both kinds is now held to both, and to the tighter of the two validity ceilings.
+
 ## v0.8.19 — 2026-09-24
 
 A code signing certificate is linted against the kind it declares itself to be.

package/README.md

@@ -290,7 +290,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) 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 CA/Browser Forum subscriber certificate profile of §7.1.2.7 (the extension presence and criticality table, the authorityInformationAccess accessMethod and accessLocation tables, basicConstraints cA and pathLenConstraint, certificatePolicies against anyPolicy and the exactly-one reserved identifier rule and the permitted-qualifier table, the forbidden extended key purposes, the two Key Usage tables that differ by key type, and the subjectAltName GeneralName table with its criticality rule in both directions), the CA/Browser Forum S/MIME BR subscriber profile of §7.1.2.3 (a) through (n) as `cabf-smime`, whose requirements follow the generation a certificate declares through its reserved policy identifier (the distribution-point and accessMethod URI scheme rules, the policy qualifier rules for an id-qt-cps URL and an id-qt-unotice explicitText and noticeRef, the key-usage table for the certificate's own key algorithm including a bit set past the nine named positions, the extended key purposes forbidden at every generation and the ones Strict alone forbids, the authorityKeyIdentifier field rules, a required mailbox in the subjectAltName as an rfc822Name or an id-on-SmtpUTF8Mailbox otherName, the criticality each extension must carry, the subjectDirectoryAttributes and Adobe extensions the Strict generation prohibits, the Legal Entity Identifier extensions keyed on the certificate type rather than the generation, and the Legacy generation retired on 15 July 2025), the CA/Browser Forum Code Signing BR subscriber profile of §7.1.2.3 as `cabf-cs`, whose rows follow the kind a certificate declares through one of the three reserved identifiers of §7.1.6.1 (the extension presence and criticality rules at the strengths this document states them, a HTTP URL required in the distribution points and in each accessMethod location, a critical keyUsage asserting digitalSignature with `keyCertSign` and `cRLSign` forbidden and every other bit discouraged, the extended key purpose each kind must carry with the critical extKeyUsage a timestamp certificate needs, the §7.1.6.4 exactly-one-identifier rule gated to 15 September 2026, the §6.3.2 ceilings of 39 months, 460 days and 135 months, and the §6.1.5.2 floors of a 3072-bit RSA modulus, NIST P-256, P-384 or P-521, or DSA parameters of 2048 bits with a 224- or 256-bit modulus length), 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.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 CA/Browser Forum subscriber certificate profile of §7.1.2.7 (the extension presence and criticality table, the authorityInformationAccess accessMethod and accessLocation tables, basicConstraints cA and pathLenConstraint, certificatePolicies against anyPolicy and the exactly-one reserved identifier rule and the permitted-qualifier table, the forbidden extended key purposes, the two Key Usage tables that differ by key type, and the subjectAltName GeneralName table with its criticality rule in both directions), the CA/Browser Forum S/MIME BR subscriber profile of §7.1.2.3 (a) through (n) as `cabf-smime`, whose requirements follow the generation a certificate declares through its reserved policy identifier (the distribution-point and accessMethod URI scheme rules, the policy qualifier rules for an id-qt-cps URL and an id-qt-unotice explicitText and noticeRef, the key-usage table for the certificate's own key algorithm including a bit set past the nine named positions, the extended key purposes forbidden at every generation and the ones Strict alone forbids, the authorityKeyIdentifier field rules, a required mailbox in the subjectAltName as an rfc822Name or an id-on-SmtpUTF8Mailbox otherName, the criticality each extension must carry, the subjectDirectoryAttributes and Adobe extensions the Strict generation prohibits, the Legal Entity Identifier extensions keyed on the certificate type rather than the generation, and the Legacy generation retired on 15 July 2025), the CA/Browser Forum Code Signing BR subscriber profile of §7.1.2.3 as `cabf-cs`, whose rows follow the kind a certificate declares through one of the three reserved identifiers of §7.1.6.1 (the extension presence and criticality rules at the strengths this document states them, a HTTP URL required in the distribution points and in each accessMethod location, a critical keyUsage asserting digitalSignature with `keyCertSign` and `cRLSign` forbidden and every other bit discouraged, the extended key purpose each kind must carry with the critical extKeyUsage a timestamp certificate needs, the §7.1.6.4 exactly-one-identifier rule gated to 15 September 2026, the §6.3.2 ceilings of 39 months, 460 days and 135 months, and the §6.1.5.2 floors of a 3072-bit RSA modulus, NIST P-256, P-384 or P-521, or DSA parameters of 2048 bits with a 224- or 256-bit modulus length, and the §7.1.4.2 subject distinguished name rows: a required commonName, a prohibited domainComponent, a subject attribute made only of the metadata characters the clause names, a required organizationName and two-letter countryName, one of localityName and stateOrProvinceName, and on an EV certificate a businessCategory from the four strings the clause names, a jurisdictionCountryName and a serialNumber), the ETSI qualified-certificate profile of EN 319 412-5 as `etsi-qc` (a non-critical qcStatements extension, a QcType naming one and only one of the three purposes the clause defines, a QcPDS providing an https URL and, on an EU qualified certificate, a document in English and no more than one per language, plus the EN 319 412-1 semantics identifiers holding a subject serialNumber or organizationIdentifier to a three-character identity type reference, a two-character country code, a hyphen-minus and an identifier, with XG required of an LEI value and a name registration authority URI required of a locally defined reference), 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

@@ -224,13 +224,25 @@ function _sanDnsNames(ctx) {
   if (!d || !d.value || !Array.isArray(d.value.names)) return [];
   return d.value.names.filter(function (n) { return n && n.tagNumber === 2; }).map(function (n) { return n.value; });
 }
-function _subjectCNs(cert) {
+/** @internal Every subject attribute, flattened across the RDNs, since a distinguished name says
+ *  the same thing whether it carries one multi-valued RDN or several single-valued ones. */
+function _subjectAttributes(cert) {
   var out = [];
   ((cert.subject && cert.subject.rdns) || []).forEach(function (rdn) {
-    rdn.forEach(function (a) { if (a.type === oid.byName("commonName") && typeof a.value === "string") out.push(a.value); });
+    rdn.forEach(function (a) { out.push(a); });
   });
   return out;
 }
+/** @internal The string values of one subject attribute type, named through the registry. */
+function _subjectValuesOf(cert, name) {
+  var dotted = oid.byName(name);
+  var out = [];
+  _subjectAttributes(cert).forEach(function (a) {
+    if (a.type === dotted && typeof a.value === "string") out.push(a.value);
+  });
+  return out;
+}
+function _subjectCNs(cert) { return _subjectValuesOf(cert, "commonName"); }
 
 /** @internal The criticality RFC 5280 fixes for a certificate extension, read from the shared table
  * the certificate signer refuses to write against. The profile has its own row for each extension
@@ -739,10 +751,9 @@ function _smimeKuMatchesAMode(modes, asserted) {
  *  kind, because sec. 7.1.2.3 (f) asks one question of both; only the timestamping identifier takes
  *  the other arm. */
 var CS_KIND_BY_POLICY = Object.create(null);
-[["code-signing", "code-signing"], ["code-signing-ev", "code-signing"],
-  ["code-signing-timestamping", "timestamping"]].forEach(function (row) {
-  var dotted = oid.byName(row[0]);
-  if (dotted) CS_KIND_BY_POLICY[dotted] = row[1];
+["code-signing", "code-signing-ev", "code-signing-timestamping"].forEach(function (name) {
+  var dotted = oid.byName(name);
+  if (dotted) CS_KIND_BY_POLICY[dotted] = name;
 });
 /** @internal "Effective September 15, 2026 a Certificate issued to a Subscriber MUST contain
  *  exactly one of the reserved policy OIDs specified in Section 7.1.6.1" (sec. 7.1.6.4). Dated, so
@@ -785,30 +796,87 @@ var CS_PERMITTED_EXTRA_EKU = ["ms-lifetime-signing", "emailProtection", "ms-docu
 /** @internal Sec. 7.1.2.3 (e) names these two as MUST NOT, and every other bit beside
  *  digitalSignature as SHOULD NOT, so one sentence becomes two rows at two strengths. */
 var CS_FORBIDDEN_KU = ["keyCertSign", "cRLSign"];
+/** @internal Sec. 7.1.4.2.4 (b): the field MUST contain one of these four strings, which the clause
+ *  fixes exactly, so a differing case is a differing string. */
+var CS_BUSINESS_CATEGORIES = ["Private Organization", "Government Entity", "Business Entity",
+  "Non-Commercial Entity"];
+/** @internal Sec. 7.1.4.2.4 (c) bounds the jurisdiction fields against the LEVEL the incorporating
+ *  or registration agency operates at, which the certificate does not carry, so no row grades the
+ *  relationship between them. The clause requires the state or province at the locality level only
+ *  "where the state or province regulates the registration of the entities at the locality level",
+ *  so a country with a locality and no state is conformant for such an agency and reporting it
+ *  would fail a valid certificate. The country is required outright and has its own row. */
 
-/** @internal The kind the asserted reserved identifier declares, or null where none is asserted. */
-function _csKind(ctx) {
+/** @internal Whether a subject attribute value carries nothing but the metadata sec. 7.1.4.2.2 (d)
+ *  names, which is a full stop, a hyphen and a space. An empty value is the same statement that
+ *  the value is absent, so it is read the same way. The clause also covers "any other indication
+ *  that the value is absent, incomplete, or not applicable", which names no further characters, so
+ *  the row reports the ones it does name. */
+function _isMetadataOnlyValue(s) {
+  if (typeof s !== "string") return false;
+  for (var i = 0; i < s.length; i++) {
+    var c = s.charCodeAt(i);
+    if (c !== 46 && c !== 45 && c !== 32) return false;
+  }
+  return true;
+}
+/** @internal Whether a value is the two-letter form sec. 7.1.4.2.3 (f) requires of a country code.
+ *  The code's membership of ISO 3166-1 is not decided here, because the section names no list and
+ *  the toolkit carries none; the builders hold their own country inputs to the same two-letter
+ *  shape. */
+function _isTwoLetterCountry(s) {
+  if (typeof s !== "string" || s.length !== 2) return false;
+  for (var i = 0; i < 2; i++) {
+    var c = s.charCodeAt(i);
+    if (c < 65 || c > 90) return false;
+  }
+  return true;
+}
+
+/** @internal Which reserved identifiers the certificate ASSERTS, as a set. Order in the extension
+ *  carries no meaning, and a certificate asserting two of them claims both, so reading only the
+ *  first would let the DER order decide which rules it answers for. Sec. 7.1.6.4 reports more than
+ *  one, but only for a certificate issued on or after the date it states. */
+function _csAsserted(ctx) {
+  var out = Object.create(null);
   var d = ctx.decode("certificatePolicies");
-  if (!d || !Array.isArray(d.value)) return null;
-  var found = null;
+  if (!d || !Array.isArray(d.value)) return out;
   for (var i = 0; i < d.value.length; i++) {
     var k = CS_KIND_BY_POLICY[d.value[i].policyIdentifier];
-    if (k && found === null) found = k;
+    if (k) out[k] = true;
   }
-  return found;
+  return out;
 }
 /** @internal Sec. 7.1.6.3 gives a subordinate CA these identifiers too, so detection asks for the
  *  identifier AND that the certificate is not a CA, as the S/MIME profile does and for the same
  *  reason. Naming the profile overrides, which is how a malformed subscriber is checked. */
 function _isCs(cert, ctx) {
   if (ctx.explicitCsProfile) return true;
-  return _csKind(ctx) !== null && !ctx.isCaCert;
+  var a = _csAsserted(ctx);
+  var any = a["code-signing"] === true || a["code-signing-ev"] === true ||
+    a["code-signing-timestamping"] === true;
+  return any && !ctx.isCaCert;
 }
 /** @internal A certificate declaring no kind is read as a code signing one, which is the arm the
  *  section states first and the only arm a caller who named the profile without a reserved
  *  identifier can have meant. */
-function _isCsTimestamp(cert, ctx) { return _isCs(cert, ctx) && _csKind(ctx) === "timestamping"; }
-function _isCsCodeSigning(cert, ctx) { return _isCs(cert, ctx) && _csKind(ctx) !== "timestamping"; }
+function _isCsTimestamp(cert, ctx) {
+  return _isCs(cert, ctx) && _csAsserted(ctx)["code-signing-timestamping"] === true;
+}
+/** @internal A certificate asserting a code signing identifier is one, and so is a certificate
+ *  asserting none, which is the arm the section states first and the only arm a caller who named
+ *  the profile without an identifier can have meant. A certificate asserting the timestamping
+ *  identifier alone is not. */
+function _isCsCodeSigning(cert, ctx) {
+  if (!_isCs(cert, ctx)) return false;
+  var a = _csAsserted(ctx);
+  if (a["code-signing"] === true || a["code-signing-ev"] === true) return true;
+  return a["code-signing-timestamping"] !== true;
+}
+/** @internal Sec. 7.1.4.2.4 covers EV code signing certificates alone, where sec. 7.1.4.2.3 covers
+ *  non-EV ones and sec. 7.1.4.2.2 covers both. None of the three names a Timestamp Certificate, so
+ *  the subject rows are scoped by the arm rather than by the profile. */
+function _isCsEv(cert, ctx) { return _isCs(cert, ctx) && _csAsserted(ctx)["code-signing-ev"] === true; }
 /** @internal The accessLocation URIs of the two accessMethods sec. 7.1.2.3 (c) names, flat: unlike
  *  the S/MIME clause this one states one rule for both, so they are not grouped by method. A
  *  location that is not a uniformResourceIdentifier is kept as null, since the method is still
@@ -1534,6 +1602,345 @@ var CABF_SMIME_RULES = [
   },
 ];
 
+/** @internal The three purposes ETSI EN 319 412-5 clause 4.2.3 names, of which a QcType declares
+ *  "one and only one". The ASN.1 carries an extension marker, so an identifier outside the three
+ *  is admitted and is not one of the purposes being counted. */
+var QC_TYPE_PURPOSES = ["qctEsign", "qctEseal", "qctWeb"].map(function (n) { return oid.byName(n); });
+/** @internal The identity type references EN 319 412-1 sec. 5.1.3 and 5.1.4 define, each three
+ *  characters. A reference may instead be the locally defined form, two characters and a colon,
+ *  which is three characters as well, so the two forms differ in which references are admitted and
+ *  not in where the country code begins. The clause's own examples read "PASSK-P3000180" and
+ *  "EI:SE-200007292386". */
+var QC_NATURAL_TYPES = ["PAS", "IDC", "PNO", "TAX", "TIN"];
+var QC_LEGAL_TYPES = ["VAT", "NTR", "PSD", "LEI"];
+/** @internal "The value 'TAX' is deprecated. The value 'TIN' should be used instead."
+ *  (NAT-5.1.3-04), a SHOULD, so the row that reports it is graded below the structural ones. */
+var QC_DEPRECATED_NATURAL_TYPE = "TAX";
+/** @internal "LEI ... The 2 character ISO 3166-1 country code shall be set to 'XG'"
+ *  (LEG-5.1.4-03). */
+var QC_LEI_COUNTRY = "XG";
+
+/** @internal An identity type reference as EN 319 412-1 writes it, with the rest of the value, or
+ *  null where the value takes neither form. The locally defined form is two characters and a
+ *  colon; every defined reference is three characters. Both are followed by a two-character
+ *  country code and a hyphen-minus. */
+function _qcIdentityParts(value) {
+  if (typeof value !== "string") return null;
+  var localForm = value.length > 2 && value.charCodeAt(2) === 58;
+  var ref = value.slice(0, 3);
+  var rest = value.slice(3);
+  if (rest.length < 3 || rest.charCodeAt(2) !== 45) return null;
+  var country = rest.slice(0, 2);
+  for (var i = 0; i < 2; i++) {
+    var c = country.charCodeAt(i);
+    if ((c < 65 || c > 90) && (c < 97 || c > 122)) return null;
+  }
+  if (rest.length <= 3) return null;
+  return { reference: ref, local: localForm, country: country, identifier: rest.slice(3) };
+}
+/** @internal Whether an identity type reference is one the clause defines, in either form. */
+function _qcKnownReference(parts, defined) {
+  if (parts === null) return false;
+  if (parts.local) return true;
+  return defined.indexOf(parts.reference) !== -1;
+}
+/** @internal EVERY SemanticsInformation the certificate carries that names an identifier. RFC 3739
+ *  sec. 3.2.6 puts no cardinality on QCStatements, so a certificate may carry more than one, and
+ *  reading only the first would let their order in the extension suppress a rule. Both statement
+ *  versions carry the same syntax. */
+function _qcSemanticsAll(ctx) {
+  var out = [];
+  var d = ctx.decode("qcStatements");
+  if (!d || !Array.isArray(d.value)) return out;
+  var v1 = oid.byName("qcsPkixQCSyntaxV1"), v2 = oid.byName("qcsPkixQCSyntaxV2");
+  for (var i = 0; i < d.value.length; i++) {
+    var st = d.value[i];
+    if (st.statementId !== v1 && st.statementId !== v2) continue;
+    if (st.info && st.info.semanticsIdentifier) out.push(st.info);
+  }
+  return out;
+}
+/** @internal The decoded info of EVERY statement of one name, for the same reason. */
+function _qcStatementInfos(ctx, name) {
+  var out = [];
+  var d = ctx.decode("qcStatements");
+  if (!d || !Array.isArray(d.value)) return out;
+  var dotted = oid.byName(name);
+  for (var i = 0; i < d.value.length; i++) {
+    if (d.value[i].statementId === dotted) out.push(d.value[i].info === null ? {} : d.value[i].info);
+  }
+  return out;
+}
+/** @internal The SemanticsInformation where it names one of the two identifiers EN 319 412-1
+ *  defines, or null. The requirements of sec. 5.1.3 and 5.1.4 each sit under their own identifier,
+ *  so a certificate naming a private one is held to neither. */
+/** @internal Whether ANY qcsPkixQCSyntax statement names a given semantics identifier. */
+function _qcNamesSemantics(ctx, name) {
+  var dotted = oid.byName(name);
+  return _qcSemanticsAll(ctx).some(function (info) { return info.semanticsIdentifier === dotted; });
+}
+function _qcEtsiSemanticsAll(ctx) {
+  var nat = oid.byName("semanticsId-Natural"), leg = oid.byName("semanticsId-Legal");
+  return _qcSemanticsAll(ctx).filter(function (info) {
+    return info.semanticsIdentifier === nat || info.semanticsIdentifier === leg;
+  });
+}
+/** @internal Whether a subject attribute names the locally defined identity type reference form,
+ *  which is what conditions the name registration authority requirements. */
+function _qcHasLocalReference(cert, attr) {
+  var values = _subjectValuesOf(cert, attr);
+  for (var i = 0; i < values.length; i++) {
+    var parts = _qcIdentityParts(values[i]);
+    if (parts !== null && parts.local) return true;
+  }
+  return false;
+}
+function _qcHasStatement(ctx, name) {
+  var d = ctx.decode("qcStatements");
+  if (!d || !Array.isArray(d.value)) return false;
+  var dotted = oid.byName(name);
+  for (var i = 0; i < d.value.length; i++) {
+    if (d.value[i].statementId === dotted) return true;
+  }
+  return false;
+}
+/** @internal A certificate carrying the extension at all, which is what clause 4 governs. */
+function _isQc(cert, ctx) { return !!ctx.raw("qcStatements"); }
+/** @internal An EU qualified certificate, which is what clause 5 governs. Table 1A reads it off
+ *  the bytes: QcCompliance says the certificate is qualified, and QcCClegislation names the
+ *  country or countries whose framework it is qualified under, so with that statement present the
+ *  certificate claims a framework other than the Regulation and clause 5 does not bind it. */
+function _isEuQc(cert, ctx) {
+  return _isQc(cert, ctx) && _qcHasStatement(ctx, "qcCompliance") &&
+    !_qcHasStatement(ctx, "qcCClegislation");
+}
+/** @internal Whether the name registration authorities carry a uniformResourceIdentifier, which
+ *  NAT-5.1.3-06 and LEG-5.1.4-05 both require of them. A decoded GeneralName names its form in
+ *  `tagNumber`; the `tag` an accessDescription carries is that record rebuilt by its own decoder,
+ *  and these are the plain form. */
+function _qcHasUriAuthority(info) {
+  var list = info && info.nameRegistrationAuthorities;
+  if (!Array.isArray(list)) return false;
+  for (var i = 0; i < list.length; i++) {
+    if (list[i] && list[i].tagNumber === 6) return true;
+  }
+  return false;
+}
+
+/** @internal The ETSI qualified-certificate profile, from EN 319 412-5 V2.4.1 and the semantics
+ *  identifiers of EN 319 412-1 V1.5.1. Clause 4 governs any certificate carrying the extension and
+ *  clause 5 an EU qualified one, so the two scopes are separate predicates. */
+var ETSI_QC_RULES = [
+  {
+    id: "lint/etsi-qc/qc-statements-critical", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-5 QCS-4.1-02",
+    message: "the qcStatements extension must not be marked critical",
+    appliesTo: _isQc,
+    check: function (cert, ctx) {
+      var e = ctx.raw("qcStatements");
+      return (e && e.critical === true) ? true : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-type-multiple-purposes", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-5 4.2.3",
+    /** @internal "declares that a CERTIFICATE is issued as one and only one of the purposes of
+     * electronic signature, electronic seal or web site authentication", so the limit is on the
+     * certificate and the purposes are counted across every QcType statement it carries: two
+     * statements naming one purpose each break the same rule as one naming two. The QcType ASN.1
+     * carries an extension marker, so an identifier outside the three is admitted and is not one
+     * of the purposes being counted. */
+    message: "the certificate names more than one of the three purposes this clause defines",
+    appliesTo: _isQc,
+    check: function (cert, ctx) {
+      var named = [];
+      _qcStatementInfos(ctx, "qcType").forEach(function (info) {
+        if (!Array.isArray(info.types)) return;
+        info.types.forEach(function (d) {
+          if (QC_TYPE_PURPOSES.indexOf(d) !== -1 && named.indexOf(d) === -1) named.push(d);
+        });
+      });
+      return named.length > 1 ? { context: { purposes: named } } : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-pds-no-https-url", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-5 QCS-4.3.4-03",
+    /** @internal "As a minimum, a URL to a PDS provided in this statement shall use the https
+     * scheme", which is the at-least-one reading: reporting each URL that is not https would fail
+     * a statement the clause admits. */
+    message: "a QcPDS statement provides no https URL",
+    appliesTo: function (cert, ctx) { return _isQc(cert, ctx) && _qcHasStatement(ctx, "qcPDS"); },
+    check: function (cert, ctx) {
+      var out = [];
+      _qcStatementInfos(ctx, "qcPDS").forEach(function (info) {
+        if (!Array.isArray(info.locations)) return;
+        var https = info.locations.filter(function (l) {
+          return pkiBuild.httpUrlScheme(l && l.url) === "https";
+        });
+        if (!https.length) out.push({ context: { locations: info.locations.length } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-pds-no-english", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-5 table 2",
+    /** @internal "it shall provide at least one URL to a PDS in English", an additional
+     * requirement Table 2 states on the QcPDS statement, so it binds an EU qualified certificate
+     * and no other. The language is an ISO 639-1 code (QCS-4.3.4-01), where English is "en". */
+    message: "an EU qualified certificate's QcPDS statement names no document in English",
+    appliesTo: function (cert, ctx) { return _isEuQc(cert, ctx) && _qcHasStatement(ctx, "qcPDS"); },
+    check: function (cert, ctx) {
+      var out = [];
+      _qcStatementInfos(ctx, "qcPDS").forEach(function (info) {
+        if (!Array.isArray(info.locations)) return;
+        var english = info.locations.filter(function (l) {
+          return typeof l.language === "string" && l.language.toLowerCase() === "en";
+        });
+        if (!english.length) {
+          out.push({ context: { languages: info.locations.map(function (l) { return l.language; }) } });
+        }
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-pds-duplicate-language", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-5 table 2",
+    /** @internal "it shall not reference more than one PDS per language", the other additional
+     * requirement Table 2 states on the same statement. */
+    message: "an EU qualified certificate's QcPDS statement names more than one document in a language",
+    appliesTo: function (cert, ctx) { return _isEuQc(cert, ctx) && _qcHasStatement(ctx, "qcPDS"); },
+    check: function (cert, ctx) {
+      var out = [];
+      _qcStatementInfos(ctx, "qcPDS").forEach(function (info) {
+        if (!Array.isArray(info.locations)) return;
+        var seen = Object.create(null);
+        info.locations.forEach(function (l) {
+          if (typeof l.language !== "string") return;
+          var key = l.language.toLowerCase();
+          if (seen[key]) { out.push({ context: { language: l.language } }); return; }
+          seen[key] = true;
+        });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-natural-serial-number-structure", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-1 NAT-5.1.3-02 and NAT-5.1.3-03",
+    /** @internal "When the natural person semantics identifier is included, any present
+     * serialNumber attribute in the subject field shall contain information using the following
+     * structure": a three character identity type reference, a two character country code, a
+     * hyphen-minus, and an identifier. The reference is one the clause defines or the locally
+     * defined form of two characters and a colon. */
+    message: "a subject serialNumber does not take the structure the natural person semantics identifier requires",
+    appliesTo: function (cert, ctx) {
+      return _isQc(cert, ctx) && _qcNamesSemantics(ctx, "semanticsId-Natural") &&
+        _subjectValuesOf(cert, "serialNumber").length > 0;
+    },
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "serialNumber").forEach(function (v) {
+        var parts = _qcIdentityParts(v);
+        if (!_qcKnownReference(parts, QC_NATURAL_TYPES)) out.push({ context: { serialNumber: v } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-natural-identity-type-deprecated", severity: "warn", source: "etsi-qc", citation: "ETSI EN 319 412-1 NAT-5.1.3-04",
+    message: "the TAX identity type reference is deprecated and TIN should be used instead",
+    appliesTo: function (cert, ctx) {
+      return _isQc(cert, ctx) && _qcNamesSemantics(ctx, "semanticsId-Natural");
+    },
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "serialNumber").forEach(function (v) {
+        var parts = _qcIdentityParts(v);
+        if (parts && !parts.local && parts.reference === QC_DEPRECATED_NATURAL_TYPE) {
+          out.push({ context: { serialNumber: v } });
+        }
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-legal-organization-identifier-structure", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-1 LEG-5.1.4-02 and LEG-5.1.4-03",
+    message: "a subject organizationIdentifier does not take the structure the legal person semantics identifier requires",
+    appliesTo: function (cert, ctx) {
+      return _isQc(cert, ctx) && _qcNamesSemantics(ctx, "semanticsId-Legal") &&
+        _subjectValuesOf(cert, "organizationIdentifier").length > 0;
+    },
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "organizationIdentifier").forEach(function (v) {
+        var parts = _qcIdentityParts(v);
+        if (!_qcKnownReference(parts, QC_LEGAL_TYPES)) out.push({ context: { organizationIdentifier: v } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-legal-lei-country-not-xg", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-1 LEG-5.1.4-03",
+    /** @internal "LEI for a global Legal Entity Identifier as specified in ISO 17442. The 2
+     * character ISO 3166-1 country code shall be set to 'XG'", the one reference whose country
+     * code the clause fixes. */
+    message: "an LEI organizationIdentifier must carry the country code XG",
+    appliesTo: function (cert, ctx) {
+      return _isQc(cert, ctx) && _qcNamesSemantics(ctx, "semanticsId-Legal");
+    },
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "organizationIdentifier").forEach(function (v) {
+        var parts = _qcIdentityParts(v);
+        if (!parts || parts.local || parts.reference !== "LEI") return;
+        if (parts.country !== QC_LEI_COUNTRY) out.push({ context: { country: parts.country } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-semantics-registration-authority-missing", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-1 NAT-5.1.3-05 and LEG-5.1.4-05",
+    /** @internal "When a locally defined identity type reference is provided (two characters
+     * followed by ':'), the nameRegistrationAuthorities element of SemanticsInformation shall be
+     * present." The same sentence appears under each semantics identifier, so one row answers for
+     * both and reads whichever attribute the identifier governs. */
+    message: "a locally defined identity type reference requires a nameRegistrationAuthorities element",
+    appliesTo: function (cert, ctx) { return _isQc(cert, ctx) && _qcEtsiSemanticsAll(ctx).length > 0; },
+    check: function (cert, ctx) {
+      var out = [];
+      _qcEtsiSemanticsAll(ctx).forEach(function (info) {
+        var attr = info.semanticsIdentifier === oid.byName("semanticsId-Legal")
+          ? "organizationIdentifier" : "serialNumber";
+        if (!_qcHasLocalReference(cert, attr)) return;
+        var list = info.nameRegistrationAuthorities;
+        if (!Array.isArray(list) || !list.length) out.push({ context: { attribute: attr } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/etsi-qc/qc-semantics-registration-authority-not-uri", severity: "error", source: "etsi-qc", citation: "ETSI EN 319 412-1 NAT-5.1.3-06 and LEG-5.1.4-05",
+    /** @internal It "shall contain at least a uniformResourceIdentifier generalName", which is what
+     * makes a locally defined reference resolvable. The two clauses state it differently and the
+     * rows follow them: NAT-5.1.3-06 states it of the element itself, so it binds wherever a
+     * natural person identifier carries one, where LEG-5.1.4-05 states it inside the sentence
+     * about a locally defined reference and binds only there. Both sit under their own semantics
+     * identifier, so a certificate naming a private one is held to neither. */
+    message: "a nameRegistrationAuthorities element must carry a uniformResourceIdentifier",
+    appliesTo: function (cert, ctx) { return _isQc(cert, ctx) && _qcEtsiSemanticsAll(ctx).length > 0; },
+    check: function (cert, ctx) {
+      var out = [];
+      _qcEtsiSemanticsAll(ctx).forEach(function (info) {
+        var list = info.nameRegistrationAuthorities;
+        if (!Array.isArray(list) || !list.length) return;
+        var natural = info.semanticsIdentifier === oid.byName("semanticsId-Natural");
+        if (!natural && !_qcHasLocalReference(cert, "organizationIdentifier")) return;
+        if (!_qcHasUriAuthority(info)) {
+          out.push({ context: { semanticsIdentifier: oid.name(info.semanticsIdentifier) } });
+        }
+      });
+      return out.length ? out : null;
+    },
+  },
+];
+
 /** @internal The CA/Browser Forum Code Signing BR v3.11.0 subscriber profile. Every severity is
  *  graded against the clause the row cites, never against the same-named row of another profile:
  *  this document says MUST where the S/MIME one says SHOULD for cRLDistributionPoints criticality,
@@ -1796,10 +2203,12 @@ var CABF_CS_RULES = [
     check: function (cert, ctx) {
       var d = ctx.decode("extKeyUsage");
       if (!d || !Array.isArray(d.value)) return null;
-      var required = _isCsTimestamp(cert, ctx) ? oid.byName("timeStamping") : oid.byName("codeSigning");
+      var required = [];
+      if (_isCsTimestamp(cert, ctx)) required.push(oid.byName("timeStamping"));
+      if (_isCsCodeSigning(cert, ctx)) required.push(oid.byName("codeSigning"));
       var out = [];
       d.value.forEach(function (dotted) {
-        if (dotted === required) return;
+        if (required.indexOf(dotted) !== -1) return;
         if (CS_PERMITTED_EXTRA_EKU.indexOf(dotted) !== -1) return;
         if (CS_FORBIDDEN_EKU.indexOf(dotted) !== -1) return;
         out.push({ context: { purpose: dotted, name: oid.name(dotted) || null } });
@@ -1835,7 +2244,9 @@ var CABF_CS_RULES = [
       var v = cert.validity;
       if (!guard.time.isDate(v.notBefore) || !guard.time.isDate(v.notAfter)) return null;
       var notAfter = guard.time.instantOf(v.notAfter);
-      if (_isCsTimestamp(cert, ctx)) {
+      /** @internal A certificate claiming both kinds is held to the code signing ceiling, the
+       * tighter of the two, since it must satisfy every ceiling it claims. */
+      if (!_isCsCodeSigning(cert, ctx)) {
         var tsCeiling = guard.time.addMonths(v.notBefore, 135, _cfg, "lint/bad-input", "notBefore");
         return notAfter > guard.time.instantOf(tsCeiling)
           ? { context: { maxMonths: 135 } } : null;
@@ -1874,6 +2285,109 @@ var CABF_CS_RULES = [
       return { context: { keyAlgorithm: name || null } };
     },
   },
+  {
+    id: "lint/cabf-cs/subject-common-name-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.2 (a)",
+    message: "a code signing certificate's subject must carry a commonName",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) { return _subjectValuesOf(cert, "commonName").length ? null : true; },
+  },
+  {
+    id: "lint/cabf-cs/subject-domain-component-prohibited", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.2 (c)",
+    message: "a code signing certificate's subject must not carry a domainComponent",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) {
+      var n = _subjectValuesOf(cert, "domainComponent").length;
+      return n ? { context: { count: n } } : null;
+    },
+  },
+  {
+    id: "lint/cabf-cs/subject-attribute-metadata-only", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.2 (d)",
+    /** @internal "Subject attributes MUST NOT contain only metadata such as '.', '-', and ' '
+     * (i.e. space) characters, and/or any other indication that the value is absent, incomplete,
+     * or not applicable." Read over every attribute, since the clause names none in particular. */
+    message: "a subject attribute carries only metadata characters",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) {
+      var out = [];
+      _subjectAttributes(cert).forEach(function (a) {
+        if (typeof a.value !== "string" || !_isMetadataOnlyValue(a.value)) return;
+        out.push({ context: { attribute: oid.name(a.type) || a.type, value: a.value } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/cabf-cs/subject-organization-name-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.3 (a) / 7.1.4.2.4 (a)",
+    /** @internal Required by the non-EV subsection and again by the EV one, so the row covers both
+     * arms and cites each clause. */
+    message: "a code signing certificate's subject must carry an organizationName",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) { return _subjectValuesOf(cert, "organizationName").length ? null : true; },
+  },
+  {
+    id: "lint/cabf-cs/subject-locality-and-state-absent", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.3 (c) and (d)",
+    /** @internal localityName is "Required if the stateOrProvinceName field is absent" and the
+     * state row says the same in the other direction, so one of the two must be present and
+     * either alone satisfies both. Sec. 7.1.4.2.4 (e) carries these rows onto an EV certificate. */
+    message: "a code signing certificate's subject must carry a localityName or a stateOrProvinceName",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) {
+      return (_subjectValuesOf(cert, "localityName").length ||
+        _subjectValuesOf(cert, "stateOrProvinceName").length) ? null : true;
+    },
+  },
+  {
+    id: "lint/cabf-cs/subject-country-name-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.3 (f)",
+    message: "a code signing certificate's subject must carry a countryName",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) { return _subjectValuesOf(cert, "countryName").length ? null : true; },
+  },
+  {
+    id: "lint/cabf-cs/subject-country-name-bad-syntax", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.3 (f)",
+    /** @internal "MUST contain the two-letter ISO 3166-1 country code", with the user-assigned XX
+     * admitted by the same clause, which is itself two letters. */
+    message: "a subject countryName must be a two-letter code",
+    appliesTo: _isCsCodeSigning,
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "countryName").forEach(function (v) {
+        if (!_isTwoLetterCountry(v)) out.push({ context: { countryName: v } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/cabf-cs/subject-business-category-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.4 (b)",
+    message: "an EV code signing certificate's subject must carry a businessCategory",
+    appliesTo: _isCsEv,
+    check: function (cert) { return _subjectValuesOf(cert, "businessCategory").length ? null : true; },
+  },
+  {
+    id: "lint/cabf-cs/subject-business-category-invalid", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.4 (b)",
+    message: "a subject businessCategory must be one of the four strings this clause names",
+    appliesTo: _isCsEv,
+    check: function (cert) {
+      var out = [];
+      _subjectValuesOf(cert, "businessCategory").forEach(function (v) {
+        if (CS_BUSINESS_CATEGORIES.indexOf(v) === -1) out.push({ context: { businessCategory: v } });
+      });
+      return out.length ? out : null;
+    },
+  },
+  {
+    id: "lint/cabf-cs/subject-jurisdiction-country-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.4 (c)",
+    /** @internal The clause lists the locality and the state as required only where the agency
+     * operates at that level, and the country without that qualification. */
+    message: "an EV code signing certificate's subject must carry a jurisdictionCountryName",
+    appliesTo: _isCsEv,
+    check: function (cert) { return _subjectValuesOf(cert, "jurisdictionCountryName").length ? null : true; },
+  },
+  {
+    id: "lint/cabf-cs/subject-serial-number-missing", severity: "error", source: "cabf-cs", citation: "CABF Code Signing BR 7.1.4.2.4 (d)",
+    message: "an EV code signing certificate's subject must carry a serialNumber",
+    appliesTo: _isCsEv,
+    check: function (cert) { return _subjectValuesOf(cert, "serialNumber").length ? null : true; },
+  },
 ];
 
 var CABF_TLS_RULES = [
@@ -3527,9 +4041,10 @@ var PROFILES = Object.assign(Object.create(null), {
   "cabf-tls": CABF_TLS_RULES.concat(RFC5280_EXTENSION_SYNTAX_RULES),
   "cabf-smime": CABF_SMIME_RULES.concat(RFC5280_EXTENSION_SYNTAX_RULES),
   "cabf-cs": CABF_CS_RULES.concat(RFC5280_EXTENSION_SYNTAX_RULES),
+  "etsi-qc": ETSI_QC_RULES.concat(RFC5280_EXTENSION_SYNTAX_RULES),
 });
 var ALL_RULES = RFC5280_RULES.concat(RFC9881_RULES).concat(RFC9909_RULES).concat(RFC9935_RULES)
-  .concat(CABF_TLS_RULES).concat(CABF_SMIME_RULES).concat(CABF_CS_RULES);
+  .concat(CABF_TLS_RULES).concat(CABF_SMIME_RULES).concat(CABF_CS_RULES).concat(ETSI_QC_RULES);
 
 var CABF_TLS_CSR_RULES = CABF_TLS_RULES.filter(function (r) {
   return CABF_TLS_CSR_RULE_IDS.indexOf(r.id) !== -1;

package/lib/oid.js

@@ -83,6 +83,13 @@ var FAMILIES = Object.assign(Object.create(null), {
 
   etsiQcType: { base: [0, 4, 0, 1862, 1, 6], of: { qctEsign: 1, qctEseal: 2, qctWeb: 3 } },
 
+  /** @internal The semantics identifiers of ETSI EN 319 412-1 sec. 5.1.2, which a
+   *  SemanticsInformation names to say how a subject serialNumber or organizationIdentifier is to
+   *  be read. */
+  etsiQcsSemantics: { base: [0, 4, 0, 194121, 1], of: {
+    "semanticsId-Natural": 1, "semanticsId-Legal": 2,
+    "semanticsId-eIDASNatural": 3, "semanticsId-eIDASLegal": 4 } },
+
   msEnrollment: { base: [1, 3, 6, 1, 4, 1, 311, 21], of: {
     msCaVersion: 1, msPreviousCertHash: 2, msCertificateTemplate: 7, msApplicationPolicies: 10 } },
 

package/lib/schema-pkix.js

@@ -1990,7 +1990,10 @@ function certExtensionDecoders(ns) {
       i++;
     }
     if (i !== node.children.length) throw ns.E(C, "SemanticsInformation has unexpected trailing fields");
-    return { semanticsIdentifier: sid, nameRegistrationAuthorities: nras };
+    /** @internal The identifier resolves to its registered name the way QcType's and
+     * QcIdentMethod's values do, and stays null for one the registry does not name. */
+    return { semanticsIdentifier: sid, semanticsIdentifierName: sid === null ? null : (ns.oid.name(sid) || null),
+      nameRegistrationAuthorities: nras };
   }
   var qcInfoByOid = _create(null);
   qcInfoByOid[O("qcCompliance")] = _qcPresenceOnly("QcCompliance");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.8.19",
+  "version": "0.8.21",
   "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:226c63e5-3f86-43a6-a5bd-ad58867e4706",
+  "serialNumber": "urn:uuid:0f0cede4-1bf3-480e-818c-d982a201c398",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-24T10:24:04.955Z",
+    "timestamp": "2026-09-24T12:14:29.178Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.8.19",
+      "bom-ref": "@blamejs/pki@0.8.21",
       "type": "application",
       "name": "pki",
-      "version": "0.8.19",
+      "version": "0.8.21",
       "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.19",
+      "purl": "pkg:npm/%40blamejs/pki@0.8.21",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.8.19",
+      "ref": "@blamejs/pki@0.8.21",
       "dependsOn": []
     }
   ]