burnledger 0.5.0 → 0.6.0

package/src/keys.ts

@@ -1,4 +1,15 @@
-// Public-key file parsing shared by the CLI (and unit-testable in isolation).
+// Public-key file parsing shared by the CLI and the browser verifier, and the
+// key_list.v3 verdict (ADR-017 §5a) — unit-testable in isolation.
+
+import type { CryptoOps } from "./crypto.js";
+import {
+  buildKeyListPayload,
+  evaluateKey,
+  formatTimestamp,
+  hexToBytes,
+  keyIsUsable,
+  publicKeyFromHex,
+} from "./verify.js";
 
 export type KeyEntry = {
   key_id: string;
@@ -12,6 +23,25 @@ export type KeyEntry = {
   compromised_from?: string | null;
 };
 
+/**
+ * The published key set as /.well-known/burnledger-keys serves it: the `keys`
+ * array, and BESIDE it — in the same object — the fields of a signed
+ * key_list.v3 statement when the server signs one (ADR-017 §5a). A body with no
+ * `signature` is the unsigned list the endpoint has always served; that is not
+ * an error, it is the state of the world before §5a is deployed.
+ *
+ * Mirrors core.KeyListDocument.
+ */
+export type KeyListDocument = {
+  keys: KeyEntry[];
+  statement_issued_at?: string;
+  statement_expires_at?: string;
+  sth_tree_size?: number;
+  sth_root_hash?: string;
+  signature?: string;
+  key_id?: string;
+};
+
 /**
  * Normalize a parsed keys file to an array of key entries. Accepts a bare
  * JSON array (the generated keys.json shape), a { "keys": [...] } envelope,
@@ -19,10 +49,153 @@ export type KeyEntry = {
  * actually publishes. Throws on any other shape.
  */
 export function parseKeyEntries(parsed: unknown): KeyEntry[] {
+  return parseKeyListDocument(parsed).keys;
+}
+
+/**
+ * Read a published key set in any shape this project has ever served — a bare
+ * array, a {"keys": [...]} object, or either inside the API's {"data": ...}
+ * envelope — keeping the statement fields when the object forms carry them.
+ * Mirrors core.ParseKeyListDocument, so this CLI, the Go CLI and the browser
+ * cannot disagree about which files are key sets.
+ */
+export function parseKeyListDocument(parsed: unknown): KeyListDocument {
   const root = (parsed as { data?: unknown })?.data ?? parsed;
-  const entries = Array.isArray(root) ? root : (root as { keys?: unknown })?.keys;
+  if (Array.isArray(root)) return { keys: root as KeyEntry[] };
+  const entries = (root as { keys?: unknown })?.keys;
   if (!Array.isArray(entries)) {
     throw new Error('--keys file must be a JSON array of keys or a {"keys": [...]} object');
   }
-  return entries as KeyEntry[];
+  return root as KeyListDocument;
+}
+
+/** Verdicts about a key list. Mirrors core.KeyListResult, plus the one the CLI
+ * adds (SIGNING_KEY_NOT_IN_LIST) because core never reaches it: VerifyKeyList
+ * is told which key to trust, and this is the case where there is none to offer. */
+export const KEY_LIST_VALID = "VALID";
+export const KEY_LIST_MALFORMED = "MALFORMED_KEY_LIST";
+export const KEY_LIST_SIGNING_KEY_UNUSABLE = "KEY_LIST_SIGNING_KEY_UNUSABLE";
+export const KEY_LIST_INVALID_SIGNATURE = "INVALID_KEY_LIST_SIGNATURE";
+export const KEY_LIST_STALE = "KEY_LIST_STALE";
+export const KEY_LIST_SIGNING_KEY_ABSENT = "SIGNING_KEY_NOT_IN_LIST";
+
+/**
+ * What a run learned about where the key statuses and dates came from.
+ * Mirrors keyListEvidence in cmd/cli/keys.go: it is not a pass/fail input to
+ * certificate verification, it qualifies one. An auditor reading
+ * KEY_COMPROMISED needs to know whether that word arrived as evidence they can
+ * keep or as JSON from an endpoint trusted for one TCP connection.
+ */
+export interface KeyListEvidence {
+  /** Whether the file carried a signed statement at all. */
+  present: boolean;
+  result?: string;
+  /** The trusted key was taken from the list itself — trust-on-first-use, not proof. */
+  selfSigned: boolean;
+  /** statement_expires_at, normalized to the form Go prints. */
+  expiresAt?: string;
+}
+
+/** The whole-second RFC 3339 form every published key date uses
+ * (core.KeyTimeFormat). Entry dates are validated against it strictly, as
+ * core.KeyEntry.PublicKeyInfo does, so a date Go refuses is refused here. */
+const KEY_TIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+
+function requireKeyTime(keyId: string, field: string, value: unknown): void {
+  if (typeof value !== "string" || !KEY_TIME_RE.test(value)) {
+    throw new Error(`key ${keyId}: ${field} is not YYYY-MM-DDTHH:MM:SSZ`);
+  }
+}
+
+function requireHex(field: string, value: unknown, bytes: number): Uint8Array {
+  if (typeof value !== "string" || value.length !== bytes * 2 || !/^[0-9a-fA-F]+$/.test(value)) {
+    throw new Error(`key list: ${field} is not ${bytes} bytes of hex`);
+  }
+  return hexToBytes(value);
+}
+
+/**
+ * Check a key-list statement the way cmd/cli/keys.go does, so four verifiers
+ * agree: the trusted key is looked up IN THE LIST ITSELF (trust-on-first-use,
+ * and selfSigned says so), then core.VerifyKeyList's order — the list parses
+ * and has no duplicate, the signing key is usable at `now` under ADR-017's
+ * table, the signature verifies over the published entries, and only then
+ * freshness. A stale verdict is never returned for a signature never tested.
+ *
+ * THROWS where the Go CLI exits 2: an entry that does not parse, a key_id that
+ * is not sha256(public_key), or a statement whose fields will not read. Someone
+ * signed something the reader cannot read, and continuing as though the file
+ * were merely unsigned would throw that fact away.
+ */
+export async function verifyKeyList(
+  crypto: CryptoOps,
+  doc: KeyListDocument,
+  now: Date,
+): Promise<KeyListEvidence> {
+  if (doc.keys.length === 0) throw new Error("keys file contains no keys");
+  const signed = doc.signature !== undefined && doc.signature !== "";
+  const keys = new Map<string, Awaited<ReturnType<typeof publicKeyFromHex>>>();
+  let duplicate = false;
+  for (const e of doc.keys) {
+    if (typeof e.public_key !== "string") throw new Error(`key ${e.key_id}: public_key is not a string`);
+    const pki = await publicKeyFromHex(crypto, e.public_key, {
+      keyStatus: e.key_status,
+      notBefore: e.not_before,
+      notAfter: e.not_after ?? undefined,
+      compromisedFrom: e.compromised_from ?? undefined,
+    });
+    // The strict Go loader rules — key_id is sha256(public_key), dates are
+    // whole-second UTC — apply to a SIGNED list, whose statement signs the
+    // published strings. An unsigned list keeps this CLI's existing
+    // tolerance (an absent key_id is allowed, and the map is keyed on the
+    // derived id either way); tightening the unsigned path would refuse files
+    // it accepts today.
+    if (signed) {
+      if (e.key_id !== pki.keyId) {
+        throw new Error(`key_id ${e.key_id} does not match sha256(public_key) (${pki.keyId})`);
+      }
+      if (e.not_before != null && e.not_before !== "") requireKeyTime(e.key_id, "not_before", e.not_before);
+      if (e.not_after != null) requireKeyTime(e.key_id, "not_after", e.not_after);
+      if (e.compromised_from != null) requireKeyTime(e.key_id, "compromised_from", e.compromised_from);
+    }
+    if (keys.has(pki.keyId)) duplicate = true;
+    keys.set(pki.keyId, pki);
+  }
+
+  if (!signed) {
+    return { present: false, selfSigned: false };
+  }
+
+  // The statement's own fields. Refused rather than defaulted: a zero
+  // statement_expires_at would read as "expired", which is an answer.
+  requireHex("sth_root_hash", doc.sth_root_hash, 32);
+  const signature = requireHex("signature", doc.signature, 64);
+  if (typeof doc.key_id !== "string" || doc.key_id === "") throw new Error("key list: key_id is missing");
+  if (typeof doc.sth_tree_size !== "number" || !Number.isInteger(doc.sth_tree_size) || doc.sth_tree_size < 0) {
+    throw new Error("key list: sth_tree_size is not a non-negative integer");
+  }
+  const issued = formatTimestamp(doc.statement_issued_at);
+  const expires = formatTimestamp(doc.statement_expires_at);
+
+  const evidence: KeyListEvidence = { present: true, selfSigned: false, expiresAt: expires };
+  const signingKey = keys.get(doc.key_id);
+  if (signingKey === undefined) {
+    return { ...evidence, result: KEY_LIST_SIGNING_KEY_ABSENT };
+  }
+  evidence.selfSigned = true;
+
+  if (duplicate) return { ...evidence, result: KEY_LIST_MALFORMED };
+
+  const at = formatTimestamp(now.toISOString());
+  if (!keyIsUsable(evaluateKey(signingKey, Math.floor(Date.parse(at) / 1000)))) {
+    return { ...evidence, result: KEY_LIST_SIGNING_KEY_UNUSABLE };
+  }
+  const payload = buildKeyListPayload(doc as unknown as Record<string, unknown>);
+  if (!(await crypto.ed25519Verify(signingKey.keyBytes, payload, signature))) {
+    return { ...evidence, result: KEY_LIST_INVALID_SIGNATURE };
+  }
+  if (at < issued || at >= expires) {
+    return { ...evidence, result: KEY_LIST_STALE };
+  }
+  return { ...evidence, result: KEY_LIST_VALID };
 }

package/src/models.ts

@@ -253,6 +253,27 @@ export interface BatchAttestationError {
   readonly subjectIdentifier: string;
 }
 
+// ---------------------------------------------------------------------------
+// Batch revocation types
+// ---------------------------------------------------------------------------
+
+/** Result of POST /v1/certificates/batch-revoke. The server answers 200
+ * whether all, some or none of the ids were revoked; `errors` is the only
+ * signal of partial completion. The records in `certificates` never carry a
+ * `statusStatement` (revoking invalidates the cached one). */
+export interface BatchRevokeResponse {
+  readonly certificates: readonly CertificateResponse[];
+  readonly errors: readonly BatchRevokeError[];
+}
+
+export interface BatchRevokeError {
+  /** Position in the submitted certificateIds list. */
+  readonly index: number;
+  readonly certificateId: string;
+  /** Code and message, e.g. "NOT_FOUND: certificate not found". */
+  readonly error: string;
+}
+
 // ---------------------------------------------------------------------------
 // Certificate stats types
 // ---------------------------------------------------------------------------
@@ -305,6 +326,8 @@ export interface ApiKeyListItem {
   readonly id: string;
   readonly prefix: string;
   readonly role: ApiKeyRole;
+  /** The team the key is pinned to; undefined for an unpinned key. */
+  readonly teamId: string | undefined;
   readonly createdAt: Date;
   readonly revokedAt: Date | undefined;
 }
@@ -313,6 +336,8 @@ export interface ApiKeyResponse {
   readonly id: string;
   readonly prefix: string;
   readonly key: string;
+  /** The team the key is pinned to; undefined for an unpinned key. */
+  readonly teamId: string | undefined;
   readonly createdAt: Date;
 }
 
@@ -487,6 +512,21 @@ export function parseBatchAttestationResponse(d: Raw): BatchAttestationResponse
   };
 }
 
+function parseBatchRevokeError(d: Raw): BatchRevokeError {
+  return {
+    index: d.index,
+    certificateId: d.certificate_id,
+    error: d.error,
+  };
+}
+
+export function parseBatchRevokeResponse(d: Raw): BatchRevokeResponse {
+  return {
+    certificates: (d.certificates ?? []).map(parseCertificateResponse),
+    errors: (d.errors ?? []).map(parseBatchRevokeError),
+  };
+}
+
 function parseMonthlyCount(d: Raw): MonthlyCount {
   return {
     month: d.month,
@@ -533,6 +573,7 @@ export function parseApiKeyListItem(d: Raw): ApiKeyListItem {
     id: d.id,
     prefix: d.prefix,
     role: d.role as ApiKeyRole,
+    teamId: d.team_id ?? undefined,
     createdAt: parseDt(d.created_at),
     revokedAt: parseDtOpt(d.revoked_at),
   };
@@ -543,6 +584,7 @@ export function parseApiKeyResponse(d: Raw): ApiKeyResponse {
     id: d.id,
     prefix: d.prefix,
     key: d.key,
+    teamId: d.team_id ?? undefined,
     createdAt: parseDt(d.created_at),
   };
 }

package/src/verify.ts

@@ -19,6 +19,7 @@
 import type { CryptoOps } from "./crypto.js";
 import {
   CERTIFICATE_REVOKED,
+  UNSUPPORTED_ALGORITHM,
   UNSUPPORTED_FORMAT_VERSION,
   VerificationError,
 } from "./errors.js";
@@ -53,8 +54,22 @@ const FORMAT_VERSION_V4 = "4.0";
 const PAYLOAD_TYPE_ATTESTATION_V6 = "burnledger.attestation.v6";
 const PAYLOAD_TYPE_VERIFICATION_RECORD_V6 = "burnledger.verification_record.v6";
 const FORMAT_VERSION_V6 = "6.0";
+// v7 changes the SHAPE, not just the name: every system entry gains
+// read_only_enforcement and transport_security, and the issuer gains the
+// algorithm identifier. Its tags move for the reason v4, v5 and v6 each moved
+// theirs, and this time the bytes under them genuinely differ.
+const PAYLOAD_TYPE_ATTESTATION_V7 = "burnledger.attestation.v7";
+const PAYLOAD_TYPE_VERIFICATION_RECORD_V7 = "burnledger.verification_record.v7";
+const FORMAT_VERSION_V7 = "7.0";
 const FORMAT_VERSION_V3 = "3.0";
 
+/**
+ * The only signature scheme this SDK can check. A v7 record names its own
+ * algorithm, so a record naming anything else must be refused with its own
+ * code rather than fed to ed25519Verify and reported as a bad signature.
+ */
+const ALGORITHM_ED25519 = "ed25519";
+
 /**
  * Every format this build can read, oldest first. Mirrors core.FormatVersions()
  * in the Go source; the cross-language conformance corpus carries a fixture per
@@ -70,6 +85,7 @@ export const KNOWN_FORMAT_VERSIONS: readonly string[] = Object.freeze([
   FORMAT_VERSION_V4,
   FORMAT_VERSION_V5,
   FORMAT_VERSION_V6,
+  FORMAT_VERSION_V7,
 ]);
 
 /**
@@ -91,10 +107,13 @@ function checkFormatVersion(version: unknown): string {
   return version;
 }
 const PAYLOAD_TYPE_TREE_HEAD = "burnledger.sth.v3";
+// The domain for a tree head that names its log. See buildTreeHeadPayload.
+const PAYLOAD_TYPE_TREE_HEAD_V7 = "burnledger.sth.v7";
 const PAYLOAD_TYPE_LOG_LEAF = "burnledger.log_leaf.v3";
 // There is deliberately no verification payload type: v3 produces those facts
 // in the same enclave call that signs the certificate (ADR-016 §2).
 const PAYLOAD_TYPE_CERTIFICATE_STATUS = "burnledger.certificate_status.v3";
+const PAYLOAD_TYPE_KEY_LIST = "burnledger.key_list.v3";
 
 export function hexToBytes(hex: string): Uint8Array {
   const len = hex.length >>> 1;
@@ -258,6 +277,14 @@ const USABLE_KEY_VERDICTS: ReadonlySet<string> = new Set([
   VALID_KEY_COMPROMISED_LATER,
 ]);
 
+/** Whether a key verdict permits relying on a signature. Mirrors
+ * core.KeyIsUsable; exported so the key-list verifier (keys.ts) refuses the
+ * same set requireUsableKey refuses rather than keeping a second copy of it —
+ * a second copy is exactly how #684's fourth answer came to exist. */
+export function keyIsUsable(verdict: string): boolean {
+  return USABLE_KEY_VERDICTS.has(verdict);
+}
+
 /** Whether a key was authorized to sign at anchor time `t`.
  *
  * Returns `"VALID"` when the key clears. The anchor is seconds since the epoch
@@ -411,9 +438,23 @@ export async function verifyCertificate(
   // signed bytes from the version, so an unreadable version makes all of them
   // meaningless - and "unknown issuer key" would be the wrong thing to tell
   // someone holding a record that is merely newer than this library.
-  checkFormatVersion((certificate as Record<string, unknown>).certificate_format_version);
+  const formatVersion = checkFormatVersion(
+    (certificate as Record<string, unknown>).certificate_format_version,
+  );
 
   const issuer = certificate.issuer as Record<string, unknown>;
+  // Step 0b: can this SDK check the algorithm the record names? Asked before
+  // any signature, because verifying an Ed25519 signature over a record that
+  // says it was signed with something else answers a question nobody asked.
+  // Below v7 no record names one, so there is nothing to check.
+  if (formatVersion === FORMAT_VERSION_V7 && issuer.algorithm !== ALGORITHM_ED25519) {
+    throw new VerificationError(
+      `record names signature algorithm ${JSON.stringify(issuer.algorithm)}; ` +
+        `this version of the SDK verifies ${ALGORITHM_ED25519}. ` +
+        "The record may be genuine and simply signed with a scheme this library does not implement.",
+      UNSUPPORTED_ALGORITHM,
+    );
+  }
   const keyId = issuer.key_id as string;
 
   const pki = publicKeys.get(keyId);
@@ -592,6 +633,20 @@ export async function verifyTransparency(
     );
   }
 
+  // Same rule for the log id (Q31). transparency.log_id sits beside log_url and
+  // is the field a reader looks at to answer "which log is this?", and nothing
+  // signs it — so a holder could relabel a genuine proof as belonging to a
+  // different log while every signature still checked out. A head predating log
+  // ids has neither side set and passes.
+  const signedLogId = (sth.log_id as string | undefined) ?? "";
+  const unsignedLogId = (transparency.log_id as string | undefined) ?? "";
+  if (unsignedLogId !== signedLogId) {
+    throw new VerificationError(
+      `transparency.log_id (${JSON.stringify(unsignedLogId)}) does not match the signed ` +
+        `tree head (${JSON.stringify(signedLogId)}); it is not covered by any signature`,
+    );
+  }
+
   if (!(await verifyInclusion(crypto, leaf, index, treeSize, proofHashes, root))) {
     throw new VerificationError("merkle inclusion proof is invalid");
   }
@@ -851,20 +906,39 @@ function buildAttestationPayload(
   certFormatVersion: string,
 ): Uint8Array {
   const attestedAt = formatTimestamp(att.attested_at);
-  const systems = (att.systems as Record<string, unknown>[]).map((s) => ({
-    canonical_version: (s.canonical_version as string | null) ?? null,
-    connector_type: s.connector_type as string,
-    hash_scope: s.hash_scope as string,
-    merkle_root: s.merkle_root
-      ? toHex(s.merkle_root as string)
-      : null,
-    // The system's own observation time, not the envelope's.
-    observed_at: formatTimestamp(s.observed_at),
-    query_hash: toHex(s.query_hash as string),
-    record_count: s.record_count as number,
-    system_id: s.system_id as string,
-    system_name: s.system_name as string,
-  }));
+  // v7 signs two per-system measurements v6 leaves on a mutable row. Gated on
+  // the record's OWN version: emitting them for an older format would rebuild
+  // bytes no signer ever produced and reject every record already issued.
+  const isV7 = certFormatVersion === FORMAT_VERSION_V7;
+  const systems = (att.systems as Record<string, unknown>[]).map((s) => {
+    const sys: Record<string, unknown> = {
+      canonical_version: (s.canonical_version as string | null) ?? null,
+      connector_type: s.connector_type as string,
+      hash_scope: s.hash_scope as string,
+      merkle_root: s.merkle_root
+        ? toHex(s.merkle_root as string)
+        : null,
+      // The system's own observation time, not the envelope's.
+      observed_at: formatTimestamp(s.observed_at),
+      query_hash: toHex(s.query_hash as string),
+      record_count: s.record_count as number,
+      system_id: s.system_id as string,
+      system_name: s.system_name as string,
+    };
+    if (isV7) {
+      sys.read_only_enforcement = requireMeasured(
+        s.read_only_enforcement,
+        "read_only_enforcement",
+        s.system_name,
+      );
+      sys.transport_security = requireMeasured(
+        s.transport_security,
+        "transport_security",
+        s.system_name,
+      );
+    }
+    return sys;
+  });
 
   const payload = {
     attested_at: attestedAt,
@@ -876,9 +950,29 @@ function buildAttestationPayload(
   return canonicalJson(payload);
 }
 
+/**
+ * Read a v7 measured field that MUST be a non-empty string.
+ *
+ * A missing or non-string value cannot be turned into `""` and canonicalized:
+ * the signer never emits an empty measurement, so an empty one here would
+ * rebuild bytes no signature covers and be reported as forgery. Refusing with a
+ * document-shape message says the true thing — this record is malformed, not
+ * this record is fake.
+ */
+function requireMeasured(value: unknown, field: string, systemName: unknown): string {
+  if (typeof value !== "string" || value === "") {
+    throw new VerificationError(
+      `system ${JSON.stringify(systemName)}: ${field} is missing from a 7.0 record, ` +
+        "which signs it; the document is incomplete rather than unverifiable",
+    );
+  }
+  return value;
+}
+
 /** Domain separator for the record itself, by certificate format version. */
 function certificatePayloadType(version: string): string {
   checkFormatVersion(version);
+  if (version === FORMAT_VERSION_V7) return PAYLOAD_TYPE_VERIFICATION_RECORD_V7;
   if (version === FORMAT_VERSION_V6) return PAYLOAD_TYPE_VERIFICATION_RECORD_V6;
   if (version === FORMAT_VERSION_V5) return PAYLOAD_TYPE_CERTIFICATE_V5;
   if (version === FORMAT_VERSION_V4) return PAYLOAD_TYPE_CERTIFICATE_V4;
@@ -893,6 +987,7 @@ function certificatePayloadType(version: string): string {
  */
 function attestationPayloadType(version: string): string {
   checkFormatVersion(version);
+  if (version === FORMAT_VERSION_V7) return PAYLOAD_TYPE_ATTESTATION_V7;
   if (version === FORMAT_VERSION_V6) return PAYLOAD_TYPE_ATTESTATION_V6;
   if (version === FORMAT_VERSION_V5) return PAYLOAD_TYPE_ATTESTATION_V5;
   return PAYLOAD_TYPE_ATTESTATION;
@@ -906,19 +1001,36 @@ function buildCertificatePayload(cert: Record<string, unknown>): Uint8Array {
   // One list, keyed by system_id (ADR-016 §2). v2 signed an attestation list
   // and a verification list joined only on the human-editable system_name,
   // which made a partial deletion indistinguishable from a complete one.
-  const systems = ((cert.systems as Record<string, unknown>[]) ?? []).map((s) => ({
-    attested_at: formatTimestamp(s.attested_at),
-    attested_count: s.attested_count as number,
-    canonical_version: (s.canonical_version as string | null) ?? null,
-    connector_type: s.connector_type as string,
-    hash_scope: s.hash_scope as string,
-    merkle_root: s.merkle_root ? toHex(s.merkle_root as string) : null,
-    query_hash: toHex(s.query_hash as string),
-    system_id: s.system_id as string,
-    system_name: s.system_name as string,
-    verified_at: formatTimestamp(s.verified_at),
-    verified_count: s.verified_count as number,
-  }));
+  const version = cert.certificate_format_version as string;
+  const isV7 = version === FORMAT_VERSION_V7;
+  const systems = ((cert.systems as Record<string, unknown>[]) ?? []).map((s) => {
+    const sys: Record<string, unknown> = {
+      attested_at: formatTimestamp(s.attested_at),
+      attested_count: s.attested_count as number,
+      canonical_version: (s.canonical_version as string | null) ?? null,
+      connector_type: s.connector_type as string,
+      hash_scope: s.hash_scope as string,
+      merkle_root: s.merkle_root ? toHex(s.merkle_root as string) : null,
+      query_hash: toHex(s.query_hash as string),
+      system_id: s.system_id as string,
+      system_name: s.system_name as string,
+      verified_at: formatTimestamp(s.verified_at),
+      verified_count: s.verified_count as number,
+    };
+    if (isV7) {
+      sys.read_only_enforcement = requireMeasured(
+        s.read_only_enforcement,
+        "read_only_enforcement",
+        s.system_name,
+      );
+      sys.transport_security = requireMeasured(
+        s.transport_security,
+        "transport_security",
+        s.system_name,
+      );
+    }
+    return sys;
+  });
 
   // The attestation block carries no system list of its own: the merged list
   // above is a superset of it. verification_signature is gone entirely.
@@ -931,11 +1043,11 @@ function buildCertificatePayload(cert: Record<string, unknown>): Uint8Array {
   // Fields added after v3 are gated on the certificate's OWN version. A v3
   // certificate must reconstruct to the same bytes forever; reading these
   // unconditionally would break every certificate already issued.
-  const version = cert.certificate_format_version as string;
   // v6 carries v5's shape exactly, so it takes every gate v5 takes. Naming
   // these "Plus" rather than testing equality at each use is what stops a new
   // version from silently missing one.
-  const isV5Plus = version === FORMAT_VERSION_V5 || version === FORMAT_VERSION_V6;
+  const isV5Plus =
+    version === FORMAT_VERSION_V5 || version === FORMAT_VERSION_V6 || isV7;
   const isV4Plus = version === FORMAT_VERSION_V4 || isV5Plus;
 
   const issuerObj: Record<string, unknown> = {
@@ -943,6 +1055,12 @@ function buildCertificatePayload(cert: Record<string, unknown>): Uint8Array {
     name: issuer.name as string,
     public_key: toHex(issuer.public_key as string),
   };
+  // v7 signs the algorithm, and does so unconditionally: unlike legal_entity
+  // and enclave_pcr0, "which scheme signed this" is never unknown to a signer,
+  // so a v7 record missing it is malformed rather than merely sparse.
+  if (isV7) {
+    issuerObj.algorithm = requireMeasured(issuer.algorithm, "issuer.algorithm", "issuer");
+  }
   if (isV4Plus && typeof issuer.legal_entity === "string" && issuer.legal_entity !== "") {
     issuerObj.legal_entity = issuer.legal_entity;
   }
@@ -1021,16 +1139,37 @@ function attestationSystems(cert: Record<string, unknown>): Record<string, unkno
     observed_at: s.attested_at,
     merkle_root: s.merkle_root,
     canonical_version: s.canonical_version,
+    // Carried through so the v7 attestation payload can be rebuilt from the
+    // record. Undefined on older formats, where buildAttestationPayload never
+    // reads them.
+    read_only_enforcement: s.read_only_enforcement,
+    transport_security: s.transport_security,
   }));
 }
 
-function buildTreeHeadPayload(head: Record<string, unknown>): Uint8Array {
-  const payload = {
-    payload_type: PAYLOAD_TYPE_TREE_HEAD,
+/**
+ * Port of Go's BuildTreeHeadPayload.
+ *
+ * A head that names its log is signed in a DIFFERENT DOMAIN from one that does
+ * not (Q31). That is what makes log_id unstrippable: removing it moves the
+ * rebuild into burnledger.sth.v3 and adding one moves it into
+ * burnledger.sth.v7, and the signature fails either way. Heads signed before
+ * log ids existed carry none and reproduce exactly the bytes they always did.
+ *
+ * Exported for anchor.ts, which rebuilds the preimage of a head fetched from
+ * GET /v1/log/head. Not re-exported from index.ts: it is an internal seam
+ * between two modules of this package, not published surface.
+ */
+export function buildTreeHeadPayload(head: Record<string, unknown>): Uint8Array {
+  const logId = head.log_id;
+  const named = typeof logId === "string" && logId !== "";
+  const payload: Record<string, unknown> = {
+    payload_type: named ? PAYLOAD_TYPE_TREE_HEAD_V7 : PAYLOAD_TYPE_TREE_HEAD,
     root_hash: toHex(head.root_hash as string),
     timestamp: formatTimestamp(head.timestamp),
     tree_size: head.tree_size as number,
   };
+  if (named) payload.log_id = logId;
   return canonicalJson(payload);
 }
 
@@ -1218,6 +1357,40 @@ export function buildCertificateStatusPayload(
   return canonicalJson(payload);
 }
 
+/**
+ * Port of Go's BuildKeyListPayload (core/key_list.go).
+ *
+ * The key array is sorted by key_id before signing: canonical JSON sorts
+ * object keys but does nothing to array order, and the server has no reason to
+ * preserve any particular order across a rotation. Optional entry fields are
+ * omitted, never emitted as null, for the reason buildCertificateStatusPayload
+ * omits them. `keys` is the array exactly as HANDED to the verifier — the
+ * signature covers the published entries, not a parsed reinterpretation of
+ * them, which is what makes an edited key_status detectable.
+ */
+export function buildKeyListPayload(doc: Record<string, unknown>): Uint8Array {
+  const entries = (doc.keys as Record<string, unknown>[]).map((e) => {
+    const k: Record<string, unknown> = {};
+    if (e.compromised_from != null) k.compromised_from = e.compromised_from;
+    k.key_id = e.key_id;
+    k.key_status = e.key_status;
+    if (e.not_after != null) k.not_after = e.not_after;
+    if (e.not_before != null && e.not_before !== "") k.not_before = e.not_before;
+    k.public_key = e.public_key;
+    return k;
+  });
+  entries.sort((a, b) => ((a.key_id as string) < (b.key_id as string) ? -1 : a.key_id === b.key_id ? 0 : 1));
+  const payload: Record<string, unknown> = {
+    payload_type: PAYLOAD_TYPE_KEY_LIST,
+    keys: entries,
+    statement_expires_at: formatTimestamp(doc.statement_expires_at),
+    statement_issued_at: formatTimestamp(doc.statement_issued_at),
+    sth_root_hash: toHex(doc.sth_root_hash as string),
+    sth_tree_size: doc.sth_tree_size as number,
+  };
+  return canonicalJson(payload);
+}
+
 /** The verdict when a certificate verified but nothing said whether it was revoked. */
 export const VALID_REVOCATION_UNKNOWN = "VALID_REVOCATION_UNKNOWN";