@freedomofpress/sigstore-browser 0.1.15 → 0.1.17

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");
-  });
-});

package/src/errors.ts

@@ -1,82 +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.
-*/
-
-/**
- * Base class for all verification errors
- * Provides structured error handling with error codes
- */
-export class VerificationError extends Error {
-  constructor(public code: string, message: string) {
-    super(message);
-    this.name = 'VerificationError';
-    Object.setPrototypeOf(this, VerificationError.prototype);
-  }
-}
-
-/**
- * Error thrown when timestamp verification fails
- */
-export class TimestampError extends VerificationError {
-  constructor(message: string) {
-    super('TIMESTAMP_ERROR', message);
-    this.name = 'TimestampError';
-    Object.setPrototypeOf(this, TimestampError.prototype);
-  }
-}
-
-/**
- * Error thrown when certificate verification fails
- */
-export class CertificateError extends VerificationError {
-  constructor(message: string) {
-    super('CERTIFICATE_ERROR', message);
-    this.name = 'CertificateError';
-    Object.setPrototypeOf(this, CertificateError.prototype);
-  }
-}
-
-/**
- * Error thrown when transparency log verification fails
- */
-export class TLogError extends VerificationError {
-  constructor(message: string) {
-    super('TLOG_ERROR', message);
-    this.name = 'TLogError';
-    Object.setPrototypeOf(this, TLogError.prototype);
-  }
-}
-
-/**
- * Error thrown when signature verification fails
- */
-export class SignatureError extends VerificationError {
-  constructor(message: string) {
-    super('SIGNATURE_ERROR', message);
-    this.name = 'SignatureError';
-    Object.setPrototypeOf(this, SignatureError.prototype);
-  }
-}
-
-/**
- * Error thrown when policy verification fails
- */
-export class PolicyError extends VerificationError {
-  constructor(message: string) {
-    super('POLICY_ERROR', message);
-    this.name = 'PolicyError';
-    Object.setPrototypeOf(this, PolicyError.prototype);
-  }
-}