@typedstandards/verify-core 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -6,6 +6,107 @@ 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
+`attestation/revises/v1` (specification v0.1.10), one fetch per referenced file, and a timestamp result
+that tells a token that does not verify from one whose only fault is its chain. **A minor bump** — new
+exports, `VerifyResult` gains a field, and `Rfc3161FailReason` gains a member, so a consumer that
+builds a `VerifyResult` literal (a test double, say), or has an exhaustive `switch` or `Record` over
+the reasons, needs the new cases.
+
+- **Check #6, `metadata.signingKeyId` consistency (`checkSigningKeyIdConsistency`,
+  `SIGNING_KEY_ID_CONSISTENCY_STATUSES`; typedstandards#88).** Specification §9.2 check #6 was
+  implemented nowhere. It compares the signature envelope's `kid` with the package's
+  `metadata.signingKeyId` and reports one of:
+  - `ok` — both present and equal;
+  - `signingKeyId_mismatch` — both present and different; the one failing status (§8.3.1: the field
+    MUST equal the envelope `kid`). The result carries `kid` and `signingKeyId`;
+  - `kid_absent` — the envelope carries no `kid`; legitimate under a key-derived identifier, and on
+    legacy packages, which carry neither field;
+  - `signingKeyId_absent` — a `kid` that the signed bytes do not name, so the check cannot confirm
+    it.
+
+  `signer.identifier` is not compared: under a key-derived identifier the `kid` SHOULD be the
+  identifier, which is not a condition of this check. `VerifyResult` gains `signingKeyIdConsistency`,
+  null when there is no package, no signature envelope, or a malformed one. The captured and
+  published packages measured for this change (the three captured commitment bundles, the
+  self-certified interop fixture, the two ADR-0028 eval-run packages, and two published example
+  bundles under a key-derived identifier) read `ok`, except the legacy capture, which carries neither
+  field and reads `kid_absent`.
+- **Check #12 registers `attestation/revises/v1` (typedstandards#96).** The ratified set is sixteen
+  attestation sub-types plus `content/analysis/v1`; a node of that type read `unknown_type` and now
+  reads `ok`.
+- **One fetch per BlobRef URL per `verifyRecord` (typedstandards#90).** Under `raw-bytes/v1` with a
+  BlobRef `output`, checks #9 and #4 each fetched the file. They now share one request per URL within a
+  `verifyRecord` call, and report exactly what they reported before, including when the fetch fails and
+  when the bytes do not match. No public signature changes, and no request is added.
+- **Check #7 evaluates the TSA signature when the chain does not reach a pinned root
+  (typedstandards#94).** `verifyRfc3161Timestamp` used to return at the chain step, so for a token
+  whose chain did not reach a pinned anchor `signatureValid` read `null` whether the signature was
+  genuine or not. It now reads `true` or `false` there as well. For a consumer:
+  - `signatureValid` is `null` when an earlier step returned first (`parse_error`,
+    `unexpected_algorithm`, `imprint_mismatch`, `no_message_digest`, `content_not_bound`,
+    `no_signing_cert`, `eku_not_timestamping`), or when the signing cert's key is not a P-384 key.
+    `true` means the signature verifies under the embedded signing cert's key; that key is trusted
+    only when `chainVerified` is `true`. `false` means a P-384 key under which the signature does
+    not verify, including a malformed signature encoding;
+  - `reason` reports the token's own faults ahead of the chain's: `genTime_outside_validity`, then
+    `unexpected_algorithm` for a signing-cert key that is not P-384, then `signature_invalid`, then
+    the chain reason. A token with an unpinned chain and a signature that does not verify used to
+    read `untrusted_root` (or another chain reason) and now reads `signature_invalid`. A signing-cert
+    key that is not P-384 used to read the chain reason, or `signature_invalid` under a pinned chain,
+    and now reads `unexpected_algorithm`. `untrusted_root`, `chain_incomplete`,
+    `chain_signature_invalid` and `chain_outside_validity` are now reported only for a token whose
+    TSA signature verifies and whose `genTime` is within the signing cert's validity;
+  - **new reason `chain_outside_validity`:** an intermediate or root certificate not valid at
+    `genTime`, a chain fault. `genTime_outside_validity` now means only the signing cert. A token
+    whose signing cert is valid at `genTime` and whose intermediate or root is not used to read
+    `genTime_outside_validity` and now reads `chain_outside_validity`;
+  - **the message imprint is compared before the SignerInfo algorithms:** a token that does not bind
+    this package's hash reads `imprint_mismatch` whatever algorithms it uses. One that did so with a
+    digest or signature algorithm outside the checked set used to read `unexpected_algorithm`, and
+    `imprintMatches` was `null` for any `unexpected_algorithm` result from that check; it is now
+    `true` there;
+  - each reason now names one kind of fault, so a consumer can classify a token by `reason` alone;
+  - `verified` is unchanged: `true` only for a fully verified token chained to a pinned anchor. No
+    request is added.
+- **`KNOWN_TYPE_URIS` is exported.** The type URIs check #12 resolves `ok` (`content/analysis/v1` and
+  the sixteen attestation sub-types), frozen, so a check outside this package can compare them with the
+  specification's list.
+- **`RFC3161_FAIL_REASONS` is exported.** The thirteen reasons `verifyRfc3161Timestamp` can return,
+  as a frozen array; `Rfc3161FailReason` is now derived from it. It gains one member,
+  `chain_outside_validity`, so a consumer with an exhaustive `switch` or `Record` over it needs the
+  new case.
+
 ## 0.10.0 — 2026-09-22
 
 Specification v0.1.9 (hub ADR-0029 and ADR-0030, anchored at `typedstandards#77`): a Producer Profile

package/dist/checks.d.ts

@@ -102,6 +102,7 @@ export interface ContentProfileCheck {
  * integrity failure: both labels are signature-covered.
  */
 export declare function checkContentProfile(pkg: Record<string, unknown>): ContentProfileCheck;
+export declare const KNOWN_TYPE_URIS: readonly string[];
 export declare const TYPE_RESOLUTION_STATUSES: readonly ["ok", "implicit", "unknown_type"];
 export type TypeResolutionStatus = (typeof TYPE_RESOLUTION_STATUSES)[number];
 export interface TypeResolution {
@@ -115,6 +116,46 @@ export interface TypeResolution {
  * and renders as such — it does NOT fail verification.
  */
 export declare function resolvePackageType(pkg: Record<string, unknown>): TypeResolution;
+export declare const SIGNING_KEY_ID_CONSISTENCY_STATUSES: readonly ["ok", "signingKeyId_mismatch", "kid_absent", "signingKeyId_absent"];
+export type SigningKeyIdConsistencyStatus = (typeof SIGNING_KEY_ID_CONSISTENCY_STATUSES)[number];
+export interface SigningKeyIdConsistencyCheck {
+    status: SigningKeyIdConsistencyStatus;
+    /** On `signingKeyId_mismatch`: the signature envelope's `kid`. */
+    kid?: string;
+    /** On `signingKeyId_mismatch`: `metadata.signingKeyId` as carried, when it is
+     *  a string. */
+    signingKeyId?: string;
+}
+/**
+ * Check #6 — the signature envelope's `kid` against `metadata.signingKeyId`
+ * (spec §9.2 check #6, §8.3.1). The package's `signingKeyId` is inside the
+ * signed bytes and the envelope's `kid` is not, so a `kid` swapped on the
+ * envelope after signing leaves the signature valid; this comparison is what
+ * detects it.
+ *   - both present and equal → `ok`.
+ *   - both present and different → `signingKeyId_mismatch`, the one failing
+ *     status: §8.3.1 says `metadata.signingKeyId` MUST equal the envelope's
+ *     `kid`, and the spec reads a mismatch as envelope-vs-canonical drift. The
+ *     comparison is exact (no case or whitespace folding), and a present value
+ *     that is not a string is a mismatch.
+ *   - the envelope carries no `kid` → `kid_absent`: there is nothing to compare.
+ *     Under a key-derived `signer.identifier` (§8.5.1) `kid` is optional, and
+ *     legacy packages carry neither field; for a registry signer, check #5
+ *     carries the consequence of a missing `kid`.
+ *   - the envelope carries a `kid` and the package no `metadata.signingKeyId`
+ *     → `signingKeyId_absent`: the `kid` is bound by nothing signed, so the
+ *     check cannot confirm it. The package does not meet §8.3.1, which requires
+ *     the field; that is not evidence the envelope was changed.
+ * `undefined`, `null` and `''` count as absent on either side. Only a mismatch
+ * carries the two values, which are then the finding; otherwise they are
+ * `VerifyResult.kid` and the package's own field.
+ *
+ * `signer.identifier` is not read. Under a key-derived identifier the `kid`
+ * SHOULD be the identifier string (§8.3.1); that is not a condition of this
+ * check, and for a registry signer `kid` and `signer.identifier` differ by
+ * design. The identity cross-check is check #14's.
+ */
+export declare function checkSigningKeyIdConsistency(pkg: Record<string, unknown>, kid: string | undefined): SigningKeyIdConsistencyCheck;
 export declare const SIGNER_IDENTITY_CHECK_STATUSES: readonly ["ok", "signer_identity_mismatch", "no_signer", "no_registry_identity", "key_derived_match", "key_derived_mismatch"];
 export type SignerIdentityCheckStatus = (typeof SIGNER_IDENTITY_CHECK_STATUSES)[number];
 export interface SignerIdentityCheck {

package/dist/checks.js

@@ -1,5 +1,5 @@
 // Content-canonicalization, content-hash, and typed-standards envelope checks
-// (spec §9.2 checks #3, #4, #12, #13, #14, #15, #16) + the package-level
+// (spec §9.2 checks #3, #4, #6, #12, #13, #14, #15, #16) + the package-level
 // blob-ref walker (#9) — browser-safe.
 //
 // Factored verbatim from the server `verify.ts` (WS2); these functions were
@@ -247,12 +247,16 @@ export function checkContentProfile(pkg) {
 // v0.1 ratified node type URIs (spec §8.12.1). Recognized so check #12 resolves
 // them; only `content/analysis/v1` (+ the lifecycle sub-types) are operationalized
 // today, but the full ratified set is registered so conformant packages don't
-// render as `unknown_type`.
-const KNOWN_TYPE_URIS = [
+// render as `unknown_type`. The sixteen attestation sub-types are in the order
+// of the §8.12.1 table; `type-resolution.test.ts` holds that table's copy.
+// Exported and frozen so a check outside this package can compare the registered
+// set with the specification's list without being able to change it.
+export const KNOWN_TYPE_URIS = Object.freeze([
     'content/analysis/v1',
     'attestation/withdraws/v1',
     'attestation/reinstates/v1',
     'attestation/supersedes/v1',
+    'attestation/revises/v1',
     'attestation/publishes/v1',
     'attestation/locatedAt/v1',
     'attestation/corroborates/v1',
@@ -265,7 +269,7 @@ const KNOWN_TYPE_URIS = [
     'attestation/certifies/v1',
     'attestation/evaluates/v1',
     'attestation/conforms/v1',
-];
+]);
 export const TYPE_RESOLUTION_STATUSES = ['ok', 'implicit', 'unknown_type'];
 /**
  * Check #12 — `type` resolution. An absent field resolves to the implicit
@@ -282,6 +286,63 @@ export function resolvePackageType(pkg) {
     }
     return { status: 'unknown_type', type: raw };
 }
+// --- Envelope kid ↔ metadata.signingKeyId (spec §9.2 check #6) ---
+export const SIGNING_KEY_ID_CONSISTENCY_STATUSES = [
+    'ok',
+    'signingKeyId_mismatch',
+    'kid_absent',
+    'signingKeyId_absent',
+];
+const isAbsent = (v) => v === undefined || v === null || v === '';
+/**
+ * Check #6 — the signature envelope's `kid` against `metadata.signingKeyId`
+ * (spec §9.2 check #6, §8.3.1). The package's `signingKeyId` is inside the
+ * signed bytes and the envelope's `kid` is not, so a `kid` swapped on the
+ * envelope after signing leaves the signature valid; this comparison is what
+ * detects it.
+ *   - both present and equal → `ok`.
+ *   - both present and different → `signingKeyId_mismatch`, the one failing
+ *     status: §8.3.1 says `metadata.signingKeyId` MUST equal the envelope's
+ *     `kid`, and the spec reads a mismatch as envelope-vs-canonical drift. The
+ *     comparison is exact (no case or whitespace folding), and a present value
+ *     that is not a string is a mismatch.
+ *   - the envelope carries no `kid` → `kid_absent`: there is nothing to compare.
+ *     Under a key-derived `signer.identifier` (§8.5.1) `kid` is optional, and
+ *     legacy packages carry neither field; for a registry signer, check #5
+ *     carries the consequence of a missing `kid`.
+ *   - the envelope carries a `kid` and the package no `metadata.signingKeyId`
+ *     → `signingKeyId_absent`: the `kid` is bound by nothing signed, so the
+ *     check cannot confirm it. The package does not meet §8.3.1, which requires
+ *     the field; that is not evidence the envelope was changed.
+ * `undefined`, `null` and `''` count as absent on either side. Only a mismatch
+ * carries the two values, which are then the finding; otherwise they are
+ * `VerifyResult.kid` and the package's own field.
+ *
+ * `signer.identifier` is not read. Under a key-derived identifier the `kid`
+ * SHOULD be the identifier string (§8.3.1); that is not a condition of this
+ * check, and for a registry signer `kid` and `signer.identifier` differ by
+ * design. The identity cross-check is check #14's.
+ */
+export function checkSigningKeyIdConsistency(pkg, kid) {
+    const metadata = pkg['metadata'];
+    const signingKeyId = typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)
+        ? metadata['signingKeyId']
+        : undefined;
+    if (kid === undefined || isAbsent(kid)) {
+        return { status: 'kid_absent' };
+    }
+    if (isAbsent(signingKeyId)) {
+        return { status: 'signingKeyId_absent' };
+    }
+    if (signingKeyId === kid) {
+        return { status: 'ok' };
+    }
+    return {
+        status: 'signingKeyId_mismatch',
+        kid,
+        ...(typeof signingKeyId === 'string' ? { signingKeyId } : {}),
+    };
+}
 export const SIGNER_IDENTITY_CHECK_STATUSES = [
     'ok',
     'signer_identity_mismatch',

package/dist/rfc3161.d.ts

@@ -10,7 +10,8 @@ export interface TsaRootAnchor {
     rootKeyDer: string;
 }
 export declare const FREETSA_ROOT_ANCHORS: readonly TsaRootAnchor[];
-export type Rfc3161FailReason = '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' | '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. */
     verified: boolean;
@@ -22,18 +23,48 @@ export interface Rfc3161VerifyResult {
     ekuTimestamping: boolean | null;
     /** genTime within the signing cert's validity window. */
     withinValidity: boolean | null;
-    /** The TSA ECDSA-P384 signature verifies under the chain-validated leaf key. */
+    /**
+     * The TSA ECDSA-P384 signature verifies under the embedded signing cert's key.
+     * Evaluated whenever the token parses, uses the checked algorithms, binds this
+     * package and carries a timestamping signing cert with a P-384 key — whether or not
+     * that cert chains to a pinned root (`chainVerified`), which is what makes the key
+     * trusted. `null` when an earlier step returned first, or when the signing cert's
+     * key is not a P-384 key (`unexpected_algorithm`): a key this verifier cannot
+     * evaluate is not an invalid signature. `false` covers a P-384 key under which the
+     * signature does not verify, including a malformed signature encoding.
+     */
     signatureValid: boolean | null;
     genTime?: number;
     /** The matched root anchor name. */
     tsa?: string;
+    /**
+     * The first failing step, in this order: `parse_error`; `imprint_mismatch` (the
+     * TSTInfo imprint is not SHA-256 of this package's hash; compared before the
+     * SignerInfo algorithms); `unexpected_algorithm` (SignerInfo digest or signature
+     * algorithm outside the checked set); `no_message_digest`, `content_not_bound`;
+     * `no_signing_cert`, `eku_not_timestamping`. After the signing-cert step the token's
+     * 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` (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.
+     */
     reason?: Rfc3161FailReason;
 }
 /**
  * Verify an RFC 3161 token (base64) attests `expectedHashHex` (the package SHA-256),
  * chaining the token's embedded signing cert to a pinned TSA root. Async (the cert
  * chain uses WebCrypto RSA). A parse failure / untrusted chain is reported, not
- * thrown; `imprint_mismatch` / `content_not_bound` / `chain_signature_invalid` /
- * `signature_invalid` are the alarm signals.
+ * thrown. The message imprint is compared first, before the SignerInfo algorithms.
+ * The TSA signature is evaluated even when the chain does not reach a pinned
+ * root, and a fault of the token itself (`genTime_outside_validity`,
+ * `unexpected_algorithm` for a signing-cert key that is not P-384,
+ * `signature_invalid`) is reported ahead of a chain fault. `parse_error`, and
+ * `unexpected_algorithm` for the SignerInfo's digest or signature algorithm, still
+ * return before any signature is evaluated.
  */
 export declare function verifyRfc3161Timestamp(tokenB64: string, expectedHashHex: string, anchors?: readonly TsaRootAnchor[]): Promise<Rfc3161VerifyResult>;

package/dist/rfc3161.js

@@ -7,11 +7,21 @@
 //   2. signedAttrs.messageDigest == SHA-512(TSTInfo) — the signature is BOUND to it;
 //   3. the token's EMBEDDED signing cert chains to the PINNED FreeTSA RSA-4096 root
 //      (each link's signature verified; CA + validity-vs-genTime checked) — so the
-//      signer is trusted WITHOUT pinning the (rotatable) signing key;
+//      signer is trusted WITHOUT pinning the (rotatable) signing key. An intermediate
+//      or root not valid at genTime is a chain fault, `chain_outside_validity`;
 //   4. the signing cert carries EKU id-kp-timeStamping and its validity covers
 //      genTime;
 //   5. the TSA's ECDSA-P384 signature over SHA-512(signedAttrs) verifies under THAT
-//      chain-validated leaf key.
+//      leaf's key. The signature is evaluated whether or not step 3 reaches a pinned
+//      root (typedstandards#94), so a token that does not verify reads differently
+//      from one whose only fault is its chain; `verified` still requires all five. A
+//      leaf key that is not a P-384 key is outside the set this verifier checks: it
+//      reads `unexpected_algorithm`, not `signature_invalid`.
+//
+// Step 1 runs before the SignerInfo digest/signature algorithms are checked: it reads
+// only the TSTInfo, so a token that does not bind this package reads `imprint_mismatch`
+// whatever algorithms it uses. Each reason names one kind of fault, so a consumer can
+// classify a token by `reason` alone.
 //
 // Crypto: the leaf TSA signature is `@noble` ECDSA-P384 (the cert key); the cert
 // chain is RSASSA-PKCS1-v1.5/SHA-512 via WebCrypto (`globalThis.crypto.subtle`, a
@@ -41,6 +51,26 @@ export const FREETSA_ROOT_ANCHORS = [
         rootKeyDer: 'MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtgKODjAy8REQ2WTNqUudAnjhlCrpE6qlmQfNppeTmVvZrH4zutn+NwTaHAGpjSGv4/WRpZ1wZ3BRZ5mPUBZyLgq0YrIfQ5Fx0s/MRZPzc1r3lKWrMR9sAQx4mN4z11xFEO529L0dFJjPF9MD8Gpd2feWzGyptlelb+PqT+++fOa2oY0+NaMM7l/xcNHPOaMz0/2olk0i22hbKeVhvokPCqhFhzsuhKsmq4Of/o+t6dI7sx5h0nPMm4gGSRhfq+z6BTRgCrqQG2FOLoVFgt6iIm/BnNffUr7VDYd3zZmIwFOj/H3DKHoGik/xK3E82YA2ZulVOFRW/zj4ApjPa5OFbpIkd0pmzxzdEcL479hSA9dFiyVmSxPtY5ze1P+BE9bMU1PScpRzw8MHFXxyKqW13Qv7LWw4sbk3SciB7GACbQiVGzgkvXG6y85HOuvWNvC5GLSiyP9GlPB0V68tbxz4JVTRdw/Xn/XTFNzRBM3cq8lBOAVt/PAX5+uFcv1S9wFE8YjaBfWCP1jdBil+c4e+0tdywT2oJmYBBF/kEt1wmGwMmHunNEuQNzh1FtJY54hbUfiWi38mASE7xMtMhfj/C4SvapiDN837gYaPfs8x3KZxbX7C3YAsFnJinlwAUss1fdKar8Q/YVs7H/nU4c4Ixxxz4f67fcVqM2ITKentbCMCAwEAAQ==',
     },
 ];
+// Source-of-truth array (not just a type), as BLOB_REF_VERIFY_REASONS in blob-ref.ts,
+// so a consumer can enumerate every reason `verifyRfc3161Timestamp` can return at
+// runtime and fail when a new one arrives unclassified. Frozen: reading it cannot
+// change it.
+export const RFC3161_FAIL_REASONS = Object.freeze([
+    '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',
+]);
 // EC P-384 SPKI DER: 23-byte prefix + 97-byte uncompressed point (0x04 ‖ X ‖ Y).
 const EC_P384_SPKI_PREFIX = Uint8Array.from([
     0x30, 0x76, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01,
@@ -123,16 +153,23 @@ 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 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).
 function toRfc3161ChainReason(reason) {
     switch (reason) {
         case 'genTime_outside_validity':
-            return 'genTime_outside_validity';
+            return 'chain_outside_validity';
         case 'untrusted_root':
             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':
@@ -161,8 +198,13 @@ function fail(base, reason) {
  * Verify an RFC 3161 token (base64) attests `expectedHashHex` (the package SHA-256),
  * chaining the token's embedded signing cert to a pinned TSA root. Async (the cert
  * chain uses WebCrypto RSA). A parse failure / untrusted chain is reported, not
- * thrown; `imprint_mismatch` / `content_not_bound` / `chain_signature_invalid` /
- * `signature_invalid` are the alarm signals.
+ * thrown. The message imprint is compared first, before the SignerInfo algorithms.
+ * The TSA signature is evaluated even when the chain does not reach a pinned
+ * root, and a fault of the token itself (`genTime_outside_validity`,
+ * `unexpected_algorithm` for a signing-cert key that is not P-384,
+ * `signature_invalid`) is reported ahead of a chain fault. `parse_error`, and
+ * `unexpected_algorithm` for the SignerInfo's digest or signature algorithm, still
+ * return before any signature is evaluated.
  */
 export async function verifyRfc3161Timestamp(tokenB64, expectedHashHex, anchors = FREETSA_ROOT_ANCHORS) {
     let buf;
@@ -197,13 +239,15 @@ export async function verifyRfc3161Timestamp(tokenB64, expectedHashHex, anchors
         signatureValid: null,
         genTime: tst.genTime,
     };
-    if (token.digestAlgOid !== OID_SHA512 || token.signatureAlgOid !== OID_ECDSA_SHA512) {
-        return fail(base, 'unexpected_algorithm');
-    }
+    // The imprint reads only the TSTInfo, not the SignerInfo algorithms, so it runs
+    // first: a token that does not bind this package fails whatever it is signed with.
     base.imprintMatches =
         tst.hashAlgOid === OID_SHA256 && bytesToHex(tst.hashedMessage) === expectedHashHex.toLowerCase();
     if (!base.imprintMatches)
         return fail(base, 'imprint_mismatch');
+    if (token.digestAlgOid !== OID_SHA512 || token.signatureAlgOid !== OID_ECDSA_SHA512) {
+        return fail(base, 'unexpected_algorithm');
+    }
     if (!mdAttr)
         return fail(base, 'no_message_digest');
     base.contentBound = bytesEqual(mdAttr, sha512(token.tstInfo));
@@ -219,27 +263,47 @@ export async function verifyRfc3161Timestamp(tokenB64, expectedHashHex, anchors
     base.withinValidity = tst.genTime >= leaf.notBefore && tst.genTime <= leaf.notAfter;
     const chain = await validateChainToRoot(token.certs, leaf, anchors, tst.genTime);
     base.chainVerified = chain.ok;
-    if (!chain.ok)
-        return fail(base, chain.reason ?? 'untrusted_root');
-    base.tsa = chain.tsa;
-    if (!base.withinValidity)
-        return fail(base, 'genTime_outside_validity');
+    if (chain.ok)
+        base.tsa = chain.tsa;
     // The TSA signature: ECDSA-P384 over SHA-512(signedAttrs re-tagged [0]→SET),
-    // under the chain-validated leaf key. lowS:false — a TSA emits high-S (#119 fix).
-    const signedBytes = Uint8Array.from(rawTlv(buf, token.signedAttrs));
-    signedBytes[0] = 0x31;
+    // under the leaf's key. lowS:false — a TSA emits high-S (#119 fix). Evaluated
+    // whatever the chain read (#94): the key is trusted only if `chain.ok`, but a
+    // signature that does not verify under it is a fault of the token itself.
+    //
+    // Two separate steps. A leaf key that is not a P-384 SPKI is one this verifier
+    // cannot evaluate: `signatureValid` stays null and the token reads
+    // `unexpected_algorithm`. Only a P-384 key under which the signature does not
+    // verify (a malformed signature encoding included) is `signature_invalid`.
+    let point = null;
     try {
-        const point = extractP384Point(leaf.spkiDer);
-        base.signatureValid = p384.verify(token.signature, sha512(signedBytes), point, {
-            format: 'der',
-            prehash: false,
-            lowS: false,
-        });
+        point = extractP384Point(leaf.spkiDer);
     }
     catch {
-        base.signatureValid = false;
+        point = null;
+    }
+    if (point) {
+        const signedBytes = Uint8Array.from(rawTlv(buf, token.signedAttrs));
+        signedBytes[0] = 0x31;
+        try {
+            base.signatureValid = p384.verify(token.signature, sha512(signedBytes), point, {
+                format: 'der',
+                prehash: false,
+                lowS: false,
+            });
+        }
+        catch {
+            base.signatureValid = false;
+        }
     }
+    // The token's own faults first, then the chain's: a chain reason is reported only
+    // for a token whose signature verifies and whose genTime is within validity.
+    if (!base.withinValidity)
+        return fail(base, 'genTime_outside_validity');
+    if (!point)
+        return fail(base, 'unexpected_algorithm');
     if (!base.signatureValid)
         return fail(base, 'signature_invalid');
+    if (!chain.ok)
+        return fail(base, chain.reason ?? 'untrusted_root');
     return { ...base, verified: true };
 }

package/dist/verify.d.ts

@@ -1,7 +1,7 @@
 import { type RekorInclusionProof, type RekorInclusionResult } from './rekor-inclusion.ts';
 import { type Rfc3161VerifyResult } from './rfc3161.ts';
 import { type KeyTrustResult, type TrustRegistry, type TrustRegistryProvenance } from './trust-registry.ts';
-import { type ContentCanonicalizationResolution, type ContentHashCheck, type TypeResolution, type SignerIdentityCheck, type CaptureMethodVocabCheck, type ContentProfileCheck, type BlobRefVerification } from './checks.ts';
+import { type ContentCanonicalizationResolution, type ContentHashCheck, type TypeResolution, type SignerIdentityCheck, type SigningKeyIdConsistencyCheck, type CaptureMethodVocabCheck, type ContentProfileCheck, type BlobRefVerification } from './checks.ts';
 import { type LifecycleResolution } from './lifecycle.ts';
 import type { FetchLike } from './types.ts';
 /** The parsed signature envelope (`buildCommitmentView`'s `signature`). */
@@ -149,6 +149,10 @@ export interface VerifyResult {
     contentHash: ContentHashCheck | null;
     typeResolution: TypeResolution | null;
     signerIdentity: SignerIdentityCheck | null;
+    /** Check #6 — the envelope `kid` against `metadata.signingKeyId`. Null when
+     *  the package is absent, no signature envelope was supplied, or the
+     *  signature was malformed: there is no envelope `kid` to read. */
+    signingKeyIdConsistency: SigningKeyIdConsistencyCheck | null;
     captureMethodVocab: CaptureMethodVocabCheck | null;
     /** Check #16 — `metadata.contentProfile` (hub ADR-0029 §5). */
     contentProfile: ContentProfileCheck | null;

package/dist/verify.js

@@ -35,8 +35,50 @@ import { verifyRekorInclusion, } from "./rekor-inclusion.js";
 import { verifyRfc3161Timestamp } from "./rfc3161.js";
 import { verifyKeyTrust, legacyEmbeddedKeyTrust, } from "./trust-registry.js";
 import { applyKeyDerivedRegistryRule, applySelfCertifiedKeyTrust, compareKeyDerivedIdentifier, } from "./self-certifying.js";
-import { resolveContentCanonicalization, verifyContentHashWithFetch, resolvePackageType, checkSignerIdentity, checkCaptureMethodVocab, checkContentProfile, verifyPackageBlobRefs, } from "./checks.js";
+import { resolveContentCanonicalization, verifyContentHashWithFetch, resolvePackageType, checkSignerIdentity, checkSigningKeyIdConsistency, checkCaptureMethodVocab, checkContentProfile, verifyPackageBlobRefs, } from "./checks.js";
 import { resolveLifecycleFromLegacyColumns, } from "./lifecycle.js";
+/**
+ * A fetcher that sends at most one request per URL and replays that request's
+ * outcome to every later call for the same URL. `verifyRecord` makes one per
+ * call and hands it to checks #9 and #4, which would otherwise each fetch a
+ * raw-bytes/v1 BlobRef `output` (#90); the scope is one `verifyRecord` call.
+ *
+ * The outcome replays as it happened, so neither check reads anything
+ * differently: a fetcher that threw throws again, a non-ok response is
+ * non-ok again, and a body that could not be read fails again. The body is
+ * read once, on first demand, and every caller receives the same
+ * `ArrayBuffer`; the two checks only read it. The first call's `init` (its
+ * abort signal) governs the one request. The underlying fetcher is resolved
+ * when the request is sent (`globalThis.fetch` when none is injected), as the
+ * checks resolve it.
+ */
+function oneFetchPerUrl(fetcher) {
+    const requests = new Map();
+    return async (url, init) => {
+        let request = requests.get(url);
+        if (request === undefined) {
+            const send = fetcher ?? globalThis.fetch;
+            request = Promise.resolve()
+                .then(() => send(url, init))
+                .then((response) => ({ response }));
+            requests.set(url, request);
+        }
+        const held = await request;
+        const body = () => {
+            if (held.body === undefined)
+                held.body = held.response.arrayBuffer();
+            return held.body;
+        };
+        return {
+            ok: held.response.ok,
+            status: held.response.status,
+            headers: held.response.headers,
+            arrayBuffer: () => body(),
+            text: async () => new TextDecoder().decode(await body()),
+            json: async () => JSON.parse(new TextDecoder().decode(await body())),
+        };
+    };
+}
 /**
  * Run the §9.2 check suite. The step order mirrors the server route exactly
  * (notably: Rekor before key-trust, because a deprecated-key trust decision is
@@ -113,11 +155,14 @@ export async function verifyRecord(input, deps) {
     if (input.rfc3161Timestamp && packageHash) {
         rfc3161 = await verifyRfc3161Timestamp(input.rfc3161Timestamp, packageHash);
     }
+    // Checks #9 and #4 share one fetch per BlobRef URL: under raw-bytes/v1 with a
+    // BlobRef `output`, both read the same file (#90).
+    const blobFetch = oneFetchPerUrl(deps.fetch);
     // Step 3b — blob references embedded in the package (check #9).
     let blobRefs = [];
     let blobRefsVerified = null;
     if (pkg) {
-        blobRefs = await verifyPackageBlobRefs(pkg, { fetch: deps.fetch });
+        blobRefs = await verifyPackageBlobRefs(pkg, { fetch: blobFetch });
         if (blobRefs.length > 0) {
             blobRefsVerified = blobRefs.every((r) => r.ok);
         }
@@ -159,18 +204,22 @@ export async function verifyRecord(input, deps) {
             : applyKeyDerivedRegistryRule(keyTrust, deps.registryProvenance);
     }
     // Step 5 — canonicalization, content-hash, and envelope checks
-    // (#3/#4/#12/#14/#15/#16). #4 fetches only for a raw-bytes/v1 BlobRef output.
+    // (#3/#4/#6/#12/#14/#15/#16). #4 fetches only for a raw-bytes/v1 BlobRef output.
     let contentCanonicalization = null;
     let contentHashCheck = null;
     let typeResolution = null;
     let signerIdentity = null;
+    let signingKeyIdConsistency = null;
     let captureMethodVocab = null;
     let contentProfile = null;
     if (pkg) {
         contentCanonicalization = resolveContentCanonicalization(pkg);
-        contentHashCheck = await verifyContentHashWithFetch(pkg, contentCanonicalization, input.legacyExternalHash ?? packageHash, { fetch: deps.fetch });
+        contentHashCheck = await verifyContentHashWithFetch(pkg, contentCanonicalization, input.legacyExternalHash ?? packageHash, { fetch: blobFetch });
         typeResolution = resolvePackageType(pkg);
         signerIdentity = checkSignerIdentity(pkg, sigKid, deps.registry, sigPublicKey);
+        if (input.signature && !input.signatureMalformed) {
+            signingKeyIdConsistency = checkSigningKeyIdConsistency(pkg, input.signature.kid);
+        }
         captureMethodVocab = checkCaptureMethodVocab(pkg);
         contentProfile = checkContentProfile(pkg);
     }
@@ -205,6 +254,7 @@ export async function verifyRecord(input, deps) {
         contentHash: contentHashCheck,
         typeResolution,
         signerIdentity,
+        signingKeyIdConsistency,
         captureMethodVocab,
         contentProfile,
         lifecycle,

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.10.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",