@freedomofpress/sigstore-browser 0.1.15 → 0.1.16

package/dist/x509/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/x509/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC"}

package/dist/x509/sct.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sct.d.ts","sourceRoot":"","sources":["../../src/x509/sct.ts"],"names":[],"mappings":"AAiBA,UAAU,UAAU;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,UAAU,CAAC;CACvB;AAED,qBAAa,0BAA0B;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;gBAEnB,OAAO,EAAE,UAAU;IAU/B,IAAI,QAAQ,IAAI,IAAI,CAEnB;IAID,IAAI,SAAS,IAAI,MAAM,CA0BtB;IAEY,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;WA8B5D,KAAK,CAAC,GAAG,EAAE,UAAU,GAAG,0BAA0B;CA6CjE"}

package/eslint.config.mjs

@@ -1,31 +0,0 @@
-import simpleImportSort from "eslint-plugin-simple-import-sort";
-import * as tseslint from "typescript-eslint";
-
-export default [
-  ...tseslint.configs.recommended,
-
-  {
-    files: ["**/*.{js,ts}"],
-    languageOptions: {
-      ecmaVersion: 2022,
-      sourceType: "module",
-    },
-    plugins: {
-      "simple-import-sort": simpleImportSort,
-    },
-    rules: {
-      "simple-import-sort/imports": "error",
-      "simple-import-sort/exports": "error",
-      "@typescript-eslint/no-non-null-assertion": "warn",
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        {
-          argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-        },
-      ],
-
-      "no-delete-var": "off",
-    },
-  },
-];

package/src/bundle.ts

@@ -1,186 +0,0 @@
-type SigstoreBundleBase = {
-  mediaType: string;
-  verificationMaterial: VerificationMaterial;
-};
-
-export type SigstoreBundle =
-  | (SigstoreBundleBase & { messageSignature: MessageSignature; dsseEnvelope?: never })
-  | (SigstoreBundleBase & { messageSignature?: never; dsseEnvelope: DSSEEnvelope });
-
-export interface VerificationMaterial {
-  certificate?: Certificate;
-  x509CertificateChain?: X509CertificateChain;
-  tlogEntries: TLogEntry[];
-  timestampVerificationData?: TimestampVerificationData;
-}
-
-export interface Certificate {
-  rawBytes: string; // Base64-encoded certificate bytes
-}
-
-export interface X509CertificateChain {
-  certificates: Certificate[];
-}
-
-export interface TLogEntry {
-  logIndex: string;
-  logId: LogId;
-  kindVersion: KindVersion;
-  integratedTime: string | null; // UNIX timestamp (can be null for Rekor v2 bundles)
-  inclusionPromise?: InclusionPromise;
-  inclusionProof?: InclusionProof;
-  canonicalizedBody: string; // Base64-encoded JSON body of the log entry
-}
-
-export interface LogId {
-  keyId: string; // Base64-encoded key ID
-}
-
-export interface KindVersion {
-  kind: string;
-  version: string;
-}
-
-export interface InclusionPromise {
-  signedEntryTimestamp: string; // Base64-encoded signature over the entry
-}
-
-export interface InclusionProof {
-  logIndex: string;
-  rootHash: string; // Base64-encoded root hash of the Merkle tree
-  treeSize: string; // Number of entries in the Merkle tree
-  hashes: string[]; // Base64-encoded sibling hashes in the Merkle tree
-  checkpoint: Checkpoint;
-}
-
-export interface Checkpoint {
-  envelope: string; // Signed envelope from the transparency log
-}
-
-export interface MessageSignature {
-  messageDigest: MessageDigest;
-  signature: string; // Base64-encoded signature over the message digest
-}
-
-export interface MessageDigest {
-  algorithm: string; // Hashing algorithm, e.g., "SHA2_256"
-  digest: string; // Base64-encoded message digest
-}
-
-export interface DSSEEnvelope {
-  payload: string;
-  payloadType: string;
-  signatures: DSSESignature[];
-}
-
-export interface DSSESignature {
-  sig: string;
-  keyid?: string;
-}
-
-export interface TimestampVerificationData {
-  rfc3161Timestamps: RFC3161Timestamp[];
-}
-
-export interface RFC3161Timestamp {
-  signedTimestamp: string; // Base64-encoded RFC3161 SignedData
-}
-
-export interface InTotoStatement {
-  _type: string;
-  subject: InTotoSubject[];
-  predicateType: string;
-  predicate: Record<string, unknown>;
-}
-
-export interface InTotoSubject {
-  name: string;
-  digest: Record<string, string>;
-}
-
-const isStr = (v: unknown): v is string => typeof v === "string";
-// Bound the aggregate encoded data this verifier will decode, parse, or hash.
-const MAX_BUNDLE_STRING_CHARS = 16 * 1024 * 1024;
-function boundedStrings(): (v: unknown) => v is string {
-  let total = 0;
-  return (v: unknown): v is string => {
-    if (!isStr(v)) return false;
-    total += v.length;
-    return total <= MAX_BUNDLE_STRING_CHARS;
-  };
-}
-// Protobuf log indices, tree sizes and times are non-negative int64 values.
-// Bound the string before BigInt conversion to avoid unbounded arithmetic.
-const isInt64 = (v: unknown): v is string =>
-  isStr(v) && /^\d{1,19}$/.test(v) && BigInt(v) <= 9223372036854775807n;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const isObj = (v: unknown): v is Record<string, any> => typeof v === "object" && v !== null;
-
-function check(cond: unknown, what: string): asserts cond {
-  if (!cond) throw new Error(`Invalid bundle: ${what}`);
-}
-
-function checkTimestampVerificationData(
-  data: unknown,
-  isBoundedStr: (v: unknown) => v is string,
-): void {
-  if (data == null) return;
-  check(isObj(data), "timestampVerificationData");
-  const ts = data.rfc3161Timestamps;
-  check(
-    ts === undefined || (Array.isArray(ts) && ts.length <= 32 && ts.every((t: unknown) => isObj(t) && isBoundedStr(t.signedTimestamp))),
-    "rfc3161Timestamps",
-  );
-}
-
-// Lives in verifyBundleTimestamp(), which every caller routes through.
-export function assertTimestampVerificationData(data: unknown): void {
-  checkTimestampVerificationData(data, boundedStrings());
-}
-
-// Structural validation of a parsed bundle, replacing the compile-time-only type with runtime checks.
-// Entry count is capped at 32 like sigstore-go does.
-export function assertBundle(b: unknown): asserts b is SigstoreBundle {
-  const isBoundedStr = boundedStrings();
-  check(isObj(b) && isBoundedStr(b.mediaType) && isObj(b.verificationMaterial), "missing mediaType or verificationMaterial");
-  const vm = b.verificationMaterial;
-
-  const certs = vm.certificate ? [vm.certificate] : vm.x509CertificateChain?.certificates;
-  check(Array.isArray(certs) && certs.length > 0 && certs.length <= 32 && certs.every((c: unknown) => isObj(c) && isBoundedStr(c.rawBytes)), "certificate");
-
-  check(Array.isArray(vm.tlogEntries) && vm.tlogEntries.length > 0 && vm.tlogEntries.length <= 32, "tlogEntries");
-  for (const e of vm.tlogEntries) {
-    check(isObj(e) && isInt64(e.logIndex) && isBoundedStr(e.logId?.keyId) && isBoundedStr(e.canonicalizedBody), "tlog entry");
-    check(isBoundedStr(e.kindVersion?.kind) && isBoundedStr(e.kindVersion?.version), "tlog entry kindVersion");
-    check(
-      e.integratedTime == null || (isInt64(e.integratedTime) && Number.isFinite(new Date(Number(e.integratedTime) * 1000).getTime())),
-      "tlog entry integratedTime",
-    );
-    // A SET signs the integrated time, so a promise without one is malformed.
-    // SET canonicalization uses Number, which must not round the signed log index.
-    const set = e.inclusionPromise?.signedEntryTimestamp;
-    check(
-      e.inclusionPromise === undefined || (isBoundedStr(set) && set !== "" && isInt64(e.integratedTime) && Number.isSafeInteger(Number(e.logIndex))),
-      "inclusion promise",
-    );
-    const p = e.inclusionProof;
-    // An int64-sized tree requires at most 63 sibling hashes.
-    check(
-      p === undefined ||
-        (isObj(p) && isInt64(p.logIndex) && isInt64(p.treeSize) && isBoundedStr(p.rootHash) &&
-          Array.isArray(p.hashes) && p.hashes.length <= 63 && p.hashes.every(isBoundedStr) && isBoundedStr(p.checkpoint?.envelope)),
-      "inclusion proof",
-    );
-  }
-
-  checkTimestampVerificationData(vm.timestampVerificationData, isBoundedStr);
-
-  const { messageSignature: ms, dsseEnvelope: env } = b;
-  check((ms === undefined) !== (env === undefined), "exactly one of messageSignature or dsseEnvelope");
-  if (ms !== undefined) {
-    check(isObj(ms) && isBoundedStr(ms.signature) && isBoundedStr(ms.messageDigest?.algorithm) && isBoundedStr(ms.messageDigest?.digest), "messageSignature");
-  } else {
-    check(isObj(env) && isBoundedStr(env.payload) && isBoundedStr(env.payloadType), "dsseEnvelope");
-    check(Array.isArray(env.signatures) && env.signatures.length === 1 && isBoundedStr(env.signatures[0]?.sig), "dsseEnvelope must have exactly one signature");
-  }
-}

package/src/cli.ts

@@ -1,290 +0,0 @@
-#!/usr/bin/env node
-import { createHash, webcrypto } from "node:crypto";
-import { access, readFile } from "node:fs/promises";
-import path from "node:path";
-
-import {
-  base64ToUint8Array,
-  hexToUint8Array,
-  Uint8ArrayToHex,
-  Uint8ArrayToString,
-} from "@freedomofpress/crypto-browser";
-import { SigstoreBundle } from "./bundle.js";
-import { TrustedRoot } from "./interfaces.js";
-import { SigstoreVerifier } from "./sigstore.js";
-import { TrustedRootProvider } from "./trust/tuf.js";
-
-// Ensure the global Web Crypto implementation is available when running under Node.js
-if (typeof globalThis.crypto === "undefined") {
-  globalThis.crypto = webcrypto as unknown as Crypto;
-}
-
-interface CLIOptions {
-  bundlePath: string;
-  certificateIdentity: string;
-  certificateOidcIssuer: string;
-  trustedRootPath: string | undefined;
-  artifactInput: string;
-}
-
-type ArtifactInput =
-  | { type: "file"; path: string; data: Uint8Array; digestHex: string }
-  | { type: "digest"; digestHex: string };
-
-const USAGE = `Usage: sigstore-browser verify-bundle [--staging] --bundle FILE --certificate-identity IDENTITY --certificate-oidc-issuer URL [--trusted-root FILE] FILE_OR_DIGEST`;
-
-function printUsage(): void {
-  console.error(USAGE);
-}
-
-function parseArgs(argv: string[]): CLIOptions {
-  const options: Partial<CLIOptions> = {};
-  let command: string | undefined;
-  let artifactInput: string | undefined;
-
-  for (let i = 0; i < argv.length; i++) {
-    const current = argv[i];
-
-    if (current === "--help" || current === "-h") {
-      printUsage();
-      process.exit(0);
-    }
-
-    if (current.startsWith("--")) {
-      const [name, providedValue] = current.split("=", 2);
-
-      switch (name) {
-        case "--bundle": {
-          const value = providedValue ?? argv[++i];
-          if (!value) {
-            throw new Error("Missing value for --bundle");
-          }
-          options.bundlePath = value;
-          break;
-        }
-        case "--certificate-identity": {
-          const value = providedValue ?? argv[++i];
-          if (!value) {
-            throw new Error("Missing value for --certificate-identity");
-          }
-          options.certificateIdentity = value;
-          break;
-        }
-        case "--certificate-oidc-issuer": {
-          const value = providedValue ?? argv[++i];
-          if (!value) {
-            throw new Error("Missing value for --certificate-oidc-issuer");
-          }
-          options.certificateOidcIssuer = value;
-          break;
-        }
-        case "--trusted-root": {
-          const value = providedValue ?? argv[++i];
-          if (!value) {
-            throw new Error("Missing value for --trusted-root");
-          }
-          options.trustedRootPath = value;
-          break;
-        }
-        default:
-          throw new Error(`Unknown option: ${name}`);
-      }
-
-      continue;
-    }
-
-    if (!command) {
-      command = current;
-      continue;
-    }
-
-    if (!artifactInput) {
-      artifactInput = current;
-      continue;
-    }
-
-    throw new Error(`Unexpected argument: ${current}`);
-  }
-
-  if (command !== "verify-bundle") {
-    throw new Error("No command provided. Expected 'verify-bundle'.");
-  }
-
-  if (!artifactInput) {
-    throw new Error("Missing FILE_OR_DIGEST argument.");
-  }
-
-  if (!options.bundlePath) {
-    throw new Error("Missing required option --bundle");
-  }
-
-  if (!options.certificateIdentity) {
-    throw new Error("Missing required option --certificate-identity");
-  }
-
-  if (!options.certificateOidcIssuer) {
-    throw new Error("Missing required option --certificate-oidc-issuer");
-  }
-
-  return {
-    bundlePath: options.bundlePath,
-    certificateIdentity: options.certificateIdentity,
-    certificateOidcIssuer: options.certificateOidcIssuer,
-    trustedRootPath: options.trustedRootPath,
-    artifactInput,
-  };
-}
-
-async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveArtifact(input: string): Promise<ArtifactInput> {
-  const digestPrefix = "sha256:";
-
-  if (
-    input.startsWith(digestPrefix) &&
-    input.length === digestPrefix.length + 64 &&
-    /^[0-9a-fA-F]+$/.test(input.slice(digestPrefix.length)) &&
-    !(await fileExists(input))
-  ) {
-    return {
-      type: "digest",
-      digestHex: input.slice(digestPrefix.length).toLowerCase(),
-    };
-  }
-
-  const resolvedPath = path.resolve(input);
-  const artifactBuffer = await readFile(resolvedPath);
-  const digestHex = createHash("sha256").update(artifactBuffer).digest("hex");
-
-  return {
-    type: "file",
-    path: resolvedPath,
-    data: new Uint8Array(artifactBuffer),
-    digestHex,
-  };
-}
-
-async function loadTrustedRoot(
-  pathInput: string | undefined,
-): Promise<TrustedRoot> {
-  if (!pathInput) {
-    // Use TUF to fetch the latest trusted root (matches sigstore-js behavior)
-    const tufProvider = new TrustedRootProvider({
-      metadataUrl: "https://tuf-repo-cdn.sigstore.dev/",
-      targetBaseUrl: "https://tuf-repo-cdn.sigstore.dev/targets/",
-    });
-    return await tufProvider.getTrustedRoot();
-  }
-  const resolvedPath = path.resolve(pathInput);
-  const raw = await readFile(resolvedPath, "utf8");
-  return JSON.parse(raw) as TrustedRoot;
-}
-
-async function loadBundle(bundlePath: string): Promise<SigstoreBundle> {
-  const resolved = path.resolve(bundlePath);
-  const raw = await readFile(resolved, "utf8");
-  return JSON.parse(raw) as SigstoreBundle;
-}
-
-async function verifyBundle(options: CLIOptions): Promise<void> {
-  const [trustedRoot, bundle, artifact] = await Promise.all([
-    loadTrustedRoot(options.trustedRootPath),
-    loadBundle(options.bundlePath),
-    resolveArtifact(options.artifactInput),
-  ]);
-
-  const verifier = new SigstoreVerifier();
-  await verifier.loadSigstoreRoot(trustedRoot);
-
-  // Extract and verify the artifact digest from the bundle
-  let bundleDigestHex: string;
-  let bundleDigestBytes: Uint8Array;
-
-  if (bundle.messageSignature) {
-    // Regular bundle: digest is in messageSignature
-    if (bundle.messageSignature.messageDigest.algorithm !== "SHA2_256") {
-      throw new Error(
-        `Unsupported message digest algorithm: ${bundle.messageSignature.messageDigest.algorithm}`,
-      );
-    }
-
-    bundleDigestBytes = base64ToUint8Array(
-      bundle.messageSignature.messageDigest.digest,
-    );
-    bundleDigestHex = Uint8ArrayToHex(bundleDigestBytes).toLowerCase();
-  } else if (bundle.dsseEnvelope) {
-    // DSSE bundle: digest is in the in-toto statement payload
-    const payloadBytes = base64ToUint8Array(bundle.dsseEnvelope.payload);
-    const payload = JSON.parse(Uint8ArrayToString(payloadBytes));
-
-    if (!payload.subject || payload.subject.length === 0) {
-      throw new Error("DSSE payload has no subject");
-    }
-
-    // Find matching subject by comparing artifact digest with all subjects
-    let matchedSubject = null;
-    for (const subject of payload.subject) {
-      const subjectDigest = subject.digest?.["sha256"];
-      if (subjectDigest && artifact.digestHex === subjectDigest.toLowerCase()) {
-        matchedSubject = subject;
-        break;
-      }
-    }
-
-    if (!matchedSubject) {
-      throw new Error(
-        `Artifact digest ${artifact.digestHex} does not match any subject in DSSE payload`
-      );
-    }
-
-    bundleDigestHex = matchedSubject.digest["sha256"].toLowerCase();
-
-    // Convert hex digest to bytes for verification target
-    bundleDigestBytes = hexToUint8Array(bundleDigestHex);
-  } else {
-    throw new Error("Bundle does not contain a message signature or DSSE envelope");
-  }
-
-  // For non-DSSE bundles, verify the digest matches
-  if (bundle.messageSignature && artifact.digestHex !== bundleDigestHex) {
-    throw new Error(
-      "Artifact digest does not match the digest embedded in the bundle.",
-    );
-  }
-
-  const verificationTarget =
-    artifact.type === "file" ? artifact.data : bundleDigestBytes;
-  const isDigestOnly = artifact.type === "digest";
-
-  await verifier.verifyArtifact(
-    options.certificateIdentity,
-    options.certificateOidcIssuer,
-    bundle,
-    verificationTarget,
-    isDigestOnly,
-  );
-}
-
-async function main(): Promise<void> {
-  try {
-    const options = parseArgs(process.argv.slice(2));
-    await verifyBundle(options);
-    console.log("Bundle verification succeeded.");
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(error.message);
-    } else {
-      console.error(error);
-    }
-    process.exitCode = 1;
-  }
-}
-
-await main();

package/src/dsse.ts

@@ -1,49 +0,0 @@
-/*
-Copyright 2023 The Sigstore Authors.
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-const PAE_PREFIX = "DSSEv1";
-
-// DSSE Pre-Authentication Encoding
-export function preAuthEncoding(
-  payloadType: string,
-  payload: Uint8Array,
-): Uint8Array {
-  const prefix = [
-    PAE_PREFIX,
-    payloadType.length,
-    payloadType,
-    payload.length,
-    "",
-  ].join(" ");
-
-  // DSSE spec requires ASCII encoding for the prefix
-  // TextEncoder will throw if the string contains non-ASCII characters
-  const encoder = new TextEncoder();
-  const prefixBuffer = encoder.encode(prefix);
-
-  // Verify all characters are ASCII (< 128)
-  for (let i = 0; i < prefixBuffer.length; i++) {
-    if (prefixBuffer[i] > 127) {
-      throw new Error(`Invalid non-ASCII character in PAE prefix at position ${i}`);
-    }
-  }
-
-  // Concatenate prefix and payload
-  const combinedArray = new Uint8Array(prefixBuffer.length + payload.length);
-
-  combinedArray.set(prefixBuffer, 0);
-  combinedArray.set(payload, prefixBuffer.length);
-  return combinedArray;
-}

package/src/ed25519.browser.test.ts

@@ -1,76 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-// Replace crypto.subtle with a wrapper whose Ed25519 operations throw NotSupportedError, as browsers without native
-// Ed25519 do. It must be in place before crypto-browser is first imported, because it probes once and caches the result.
-const real = globalThis.crypto.subtle;
-const noEd25519 = new Proxy(real, {
-  get(target, prop) {
-    const value = Reflect.get(target, prop) as unknown;
-    if (typeof value !== "function") return value;
-    return (...args: unknown[]) => {
-      const alg = (prop === "importKey" ? args[2] : args[0]) as { name?: string } | undefined;
-      if (alg?.name === "Ed25519") {
-        return Promise.reject(new DOMException("Unrecognized name.", "NotSupportedError"));
-      }
-      return (value as (...a: unknown[]) => unknown).apply(target, args);
-    };
-  },
-});
-Object.defineProperty(globalThis.crypto, "subtle", { value: noEd25519, configurable: true });
-
-describe("Fix 7: Ed25519 log keys without native WebCrypto support", () => {
-  it("imports trusted root Ed25519 keys through the fallback and verifies a checkpoint", async () => {
-    await expect(crypto.subtle.generateKey({ name: "Ed25519" }, false, ["sign", "verify"])).rejects.toThrow();
-
-    const { SigstoreVerifier } = await import("./sigstore.js");
-    const { verifyCheckpoint } = await import("./tlog/checkpoint.js");
-    const { Uint8ArrayToBase64 } = await import("@freedomofpress/crypto-browser");
-    const { ed25519 } = await import("@noble/curves/ed25519.js");
-    const { trustRoot } = await import("../test/fixtures/sigstore.js");
-
-    // The real trusted root carries an SPKI-encoded Ed25519 key for Rekor v2.
-    const keys = await new SigstoreVerifier().loadLog(trustRoot().tlogs);
-    const rekorV2 = keys.find((k) => k.publicKey.algorithm.name === "Ed25519");
-    expect((rekorV2?.publicKey as unknown as { bytes: Uint8Array }).bytes).toHaveLength(32);
-
-    // A synthetic log whose key we control, signing a checkpoint note.
-    const priv = ed25519.utils.randomSecretKey();
-    const pub = ed25519.getPublicKey(priv);
-    const spki = new Uint8Array([0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00, ...pub]);
-    const logId = new Uint8Array(await crypto.subtle.digest("SHA-256", spki));
-    const [log] = await new SigstoreVerifier().loadLog([
-      {
-        baseUrl: "https://log.test",
-        hashAlgorithm: "SHA2_256",
-        publicKey: { rawBytes: Uint8ArrayToBase64(spki), keyDetails: "PKIX_ED25519", validFor: { start: "2025-01-01T00:00:00Z" } },
-        logId: { keyId: Uint8ArrayToBase64(logId) },
-      },
-    ]);
-
-    const rootHash = Uint8ArrayToBase64(new Uint8Array(32));
-    const note = `log.test\n7\n${rootHash}\n`;
-    const sig = ed25519.sign(new TextEncoder().encode(note), priv);
-    const sigLine = Uint8ArrayToBase64(new Uint8Array([...logId.subarray(0, 4), ...sig]));
-    const proof = (n: string) => ({
-      logIndex: "0",
-      hashes: [],
-      treeSize: "7",
-      rootHash,
-      checkpoint: { envelope: `${n}\n— log.test ${sigLine}\n` },
-    });
-    const entry = (n = note) => ({
-      logIndex: "0",
-      logId: { keyId: Uint8ArrayToBase64(logId) },
-      kindVersion: { kind: "dsse", version: "0.0.2" },
-      integratedTime: null,
-      canonicalizedBody: "",
-      inclusionProof: proof(n),
-    });
-
-    await expect(verifyCheckpoint(entry(), log)).resolves.toBeUndefined();
-    await expect(verifyCheckpoint(entry(`log.test\n8\n${rootHash}\n`), log)).rejects.toThrow("Invalid checkpoint signature");
-    const bad = entry();
-    bad.inclusionProof.treeSize = "8";
-    await expect(verifyCheckpoint(bad, log)).rejects.toThrow("does not match inclusion proof");
-  });
-});