@typedstandards/verify-core 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -6,6 +6,34 @@ references are to `npstorey/civic-ai-tools-website` (#119 is the offline-crypto
 hardening arc; #116 is the standalone-verifier arc this package was extracted
 in).
 
+## 0.12.0 — 2026-09-24
+
+The certificate-chain split (typedstandards#100, shipped in #106). **A minor bump** — `ChainFailReason`
+and `Rfc3161FailReason` each gain a member, so a consumer with an exhaustive `switch` or `Record` over
+either needs the new case.
+
+- **A chain link signed with an algorithm the validator does not implement is no longer reported as an
+  invalid signature.** `verifyCertChainToAnchor` checks each link's signature algorithm at the step
+  where it verifies the link's signature:
+  - an algorithm it does not implement (anything but RSASSA-PKCS1-v1_5 with SHA-256, SHA-384 or
+    SHA-512; an ECDSA-signed intermediate, say) reads the new reason `link_algorithm_unsupported`. It
+    used to read `link_signature_invalid`;
+  - an RSA link whose signature does not verify keeps `link_signature_invalid`;
+  - no other reason changes order, and `verifyCertSignatureRsa` is unchanged.
+- **`verifyRfc3161Timestamp` reports that link as `chain_algorithm_unsupported`**, a new reason, where
+  it used to report `chain_signature_invalid`. `RFC3161_FAIL_REASONS` holds fourteen codes.
+  `chain_signature_invalid` now means only a link whose signature does not verify: a fault in the
+  token, not a limit of the verifier. `verified` is unchanged, and no request is added.
+- **On typedstandards.org** (the site's verifier, live since #106; not part of this package's API):
+  - **a timestamp whose chain has a link with an invalid signature (`chain_signature_invalid`) now
+    fails the package, where it was a caveat.** `chain_algorithm_unsupported` is a caveat, as the
+    verifier's other policy limits are, and the #7 row reads amber for every caveat-class reason
+    (typedstandards#104);
+  - **bundle mode requests nothing.** A fully offline run gives `verifyRecord` a fetcher that sends no
+    request, so a file the package references is not fetched and reads "not checked offline", and no
+    transparency-log lookup is sent (typedstandards#105). A consumer that wants the same passes such a
+    fetcher as `VerifyDeps.fetch`.
+
 ## 0.11.0 — 2026-09-22
 
 The verifier follow-ons (anchored at `typedstandards#98`): specification check #6, the ratified

package/dist/rfc3161.d.ts

@@ -10,7 +10,7 @@ export interface TsaRootAnchor {
     rootKeyDer: string;
 }
 export declare const FREETSA_ROOT_ANCHORS: readonly TsaRootAnchor[];
-export declare const RFC3161_FAIL_REASONS: readonly ["parse_error", "unexpected_algorithm", "no_message_digest", "content_not_bound", "imprint_mismatch", "no_signing_cert", "eku_not_timestamping", "genTime_outside_validity", "chain_incomplete", "chain_signature_invalid", "chain_outside_validity", "untrusted_root", "signature_invalid"];
+export declare const RFC3161_FAIL_REASONS: readonly ["parse_error", "unexpected_algorithm", "no_message_digest", "content_not_bound", "imprint_mismatch", "no_signing_cert", "eku_not_timestamping", "genTime_outside_validity", "chain_incomplete", "chain_signature_invalid", "chain_algorithm_unsupported", "chain_outside_validity", "untrusted_root", "signature_invalid"];
 export type Rfc3161FailReason = (typeof RFC3161_FAIL_REASONS)[number];
 export interface Rfc3161VerifyResult {
     /** All checks passed: a chain-trusted TSA signed this package hash at genTime. */
@@ -46,8 +46,10 @@ export interface Rfc3161VerifyResult {
      * own faults come first: `genTime_outside_validity` (the signing cert only), then
      * `unexpected_algorithm` (a signing-cert key that is not P-384), then
      * `signature_invalid`, then the chain's reason — `untrusted_root`,
-     * `chain_incomplete`, `chain_signature_invalid`, or `chain_outside_validity` (an
-     * intermediate or root not valid at genTime). So a chain reason is reported only for
+     * `chain_incomplete`, `chain_signature_invalid` (a link whose RSA signature does not
+     * verify), `chain_algorithm_unsupported` (a link signed with an algorithm the chain
+     * validator does not implement), or `chain_outside_validity` (an intermediate or
+     * root not valid at genTime). So a chain reason is reported only for
      * a token whose TSA signature verifies and whose genTime is within the signing cert's
      * validity, and each reason names one kind of fault.
      */

package/dist/rfc3161.js

@@ -66,6 +66,7 @@ export const RFC3161_FAIL_REASONS = Object.freeze([
     'genTime_outside_validity',
     'chain_incomplete',
     'chain_signature_invalid',
+    'chain_algorithm_unsupported',
     'chain_outside_validity',
     'untrusted_root',
     'signature_invalid',
@@ -152,8 +153,10 @@ function parseTstInfo(tst) {
 }
 // Map the X.509 chain verifier's precise reason onto this module's vocabulary. The
 // strict-RFC structural/policy rejections (#119 P4) collapse to `chain_incomplete`
-// (the chain could not be trusted) and only a real RSA link failure surfaces as
-// `chain_signature_invalid`; the chain layer keeps the fine-grained reason. The
+// (the chain could not be trusted), only a real RSA link failure surfaces as
+// `chain_signature_invalid`, and a link signed with an algorithm the validator does
+// not implement is `chain_algorithm_unsupported` (#100); the chain layer keeps the
+// fine-grained reason. The
 // chain's validity failure is `chain_outside_validity`: `verifyRfc3161Timestamp`
 // reports a signing cert not valid at genTime before the chain's reason, so here it
 // can only be an intermediate or the root (typedstandards#94).
@@ -165,6 +168,8 @@ function toRfc3161ChainReason(reason) {
             return 'untrusted_root';
         case 'link_signature_invalid':
             return 'chain_signature_invalid';
+        case 'link_algorithm_unsupported':
+            return 'chain_algorithm_unsupported';
         case 'unsupported_critical_extension':
         case 'algorithm_mismatch':
         case 'issuer_not_found':

package/dist/x509.d.ts

@@ -40,7 +40,8 @@ export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
  * Verify `cert.signature` over `cert.tbsBytes` using `issuerSpkiDer` (RSA), via
  * WebCrypto (`globalThis.crypto.subtle` — a browser/Node global, not a `node:`
  * import, so verify-core stays browser-safe). Returns false for an unsupported
- * algorithm or any verification error.
+ * algorithm or any verification error; `verifyCertChainToAnchor` tells the two
+ * apart before it calls this.
  */
 export declare function verifyCertSignatureRsa(cert: X509Cert, issuerSpkiDer: Uint8Array): Promise<boolean>;
 /** A pinned trust anchor: a root whose public key is trusted by value. */
@@ -49,7 +50,7 @@ export interface ChainAnchor {
     /** Root public key, base64 SPKI DER. */
     rootKeyDer: string;
 }
-export type ChainFailReason = 'unsupported_critical_extension' | 'algorithm_mismatch' | 'genTime_outside_validity' | 'issuer_not_found' | 'issuer_not_ca' | 'path_len_exceeded' | 'link_signature_invalid' | 'untrusted_root';
+export type ChainFailReason = 'unsupported_critical_extension' | 'algorithm_mismatch' | 'genTime_outside_validity' | 'issuer_not_found' | 'issuer_not_ca' | 'path_len_exceeded' | 'link_signature_invalid' | 'link_algorithm_unsupported' | 'untrusted_root';
 export interface ChainResult {
     /** The path links to a pinned anchor and every strict check passed. */
     ok: boolean;

package/dist/x509.js

@@ -148,11 +148,18 @@ const RSA_SIG_HASH = {
     '1.2.840.113549.1.1.12': 'SHA-384',
     '1.2.840.113549.1.1.13': 'SHA-512',
 };
+/** Whether `oid` is a certificate signature algorithm `verifyCertSignatureRsa`
+ *  implements. The chain validator reports a link signed with any other algorithm as
+ *  `link_algorithm_unsupported`, not as a signature that does not verify (#100). */
+function isImplementedCertSignatureAlgorithm(oid) {
+    return Object.prototype.hasOwnProperty.call(RSA_SIG_HASH, oid);
+}
 /**
  * Verify `cert.signature` over `cert.tbsBytes` using `issuerSpkiDer` (RSA), via
  * WebCrypto (`globalThis.crypto.subtle` — a browser/Node global, not a `node:`
  * import, so verify-core stays browser-safe). Returns false for an unsupported
- * algorithm or any verification error.
+ * algorithm or any verification error; `verifyCertChainToAnchor` tells the two
+ * apart before it calls this.
  */
 export async function verifyCertSignatureRsa(cert, issuerSpkiDer) {
     const hash = RSA_SIG_HASH[cert.sigAlgOid];
@@ -207,6 +214,11 @@ export async function verifyCertChainToAnchor(certs, leaf, anchors, atTime) {
         if (issuer.pathLen !== null && depth > issuer.pathLen) {
             return { ok: false, reason: 'path_len_exceeded' }; // (c)
         }
+        // The algorithm is checked where the signature is, so the reasons before it read
+        // as they did; a link this validator cannot check is not one that fails (#100).
+        if (!isImplementedCertSignatureAlgorithm(current.sigAlgOid)) {
+            return { ok: false, reason: 'link_algorithm_unsupported' };
+        }
         if (!(await verifyCertSignatureRsa(current, issuer.spkiDer))) {
             return { ok: false, reason: 'link_signature_invalid' };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typedstandards/verify-core",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Portable, browser-safe verification core for Typed Standards record packages — the §9.2 check suite, single-sourced so it verifies identically on a server and in the browser.",
   "license": "MIT",
   "author": "Nathan Storey",