@freedomofpress/sigstore-browser 0.1.0

package/src/encoding.ts

@@ -0,0 +1,141 @@
+/*
+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.
+*/
+export function toArrayBuffer(view: ArrayBufferView): ArrayBuffer {
+  const { byteLength } = view;
+
+  if (byteLength === 0) {
+    return new ArrayBuffer(0);
+  }
+
+  const { buffer, byteOffset } = view;
+
+  if (
+    buffer instanceof ArrayBuffer &&
+    byteOffset === 0 &&
+    byteLength === buffer.byteLength
+  ) {
+    return buffer;
+  }
+
+  const clone = new Uint8Array(byteLength);
+  clone.set(new Uint8Array(buffer, byteOffset, byteLength));
+  return clone.buffer;
+}
+
+export function base64ToUint8Array(base64: string): Uint8Array {
+  const binaryString = atob(base64);
+  const length = binaryString.length;
+  const bytes = new Uint8Array(length);
+
+  for (let i = 0; i < length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+
+  return bytes;
+}
+
+export function base64UrlToUint8Array(base64url: string): Uint8Array {
+  let base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
+  while (base64.length % 4 !== 0) {
+    base64 += '=';
+  }
+  return base64ToUint8Array(base64);
+}
+
+export function Uint8ArrayToBase64(uint8Array: Uint8Array): string {
+  let binaryString = "";
+
+  for (let i = 0; i < uint8Array.length; i++) {
+    binaryString += String.fromCharCode(uint8Array[i]);
+  }
+
+  return btoa(binaryString);
+}
+
+export function hexToUint8Array(hex: string): Uint8Array {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Hex string must have an even length");
+  }
+
+  const length = hex.length / 2;
+  const uint8Array = new Uint8Array(length);
+
+  for (let i = 0; i < length; i++) {
+    uint8Array[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+
+  return uint8Array;
+}
+
+export function Uint8ArrayToHex(uint8Array: Uint8Array): string {
+  let hexString = "";
+
+  for (let i = 0; i < uint8Array.length; i++) {
+    let hex = uint8Array[i].toString(16);
+    if (hex.length === 1) {
+      hex = "0" + hex;
+    }
+    hexString += hex;
+  }
+
+  return hexString;
+}
+
+export function stringToUint8Array(str: string): Uint8Array {
+  // Defaults to utf-8, but utf-8 is ascii compatible
+  const encoder = new TextEncoder();
+  return encoder.encode(str);
+}
+
+export function Uint8ArrayToString(uint8Array: Uint8Array): string {
+  const decoder = new TextDecoder("utf-8");
+  return decoder.decode(uint8Array);
+}
+
+export function readBigInt64BE(
+  uint8Array: Uint8Array,
+  offset?: number,
+): bigint {
+  if (offset === undefined) {
+    offset = 0;
+  }
+  const hex = Uint8ArrayToHex(uint8Array.slice(offset, offset + 8));
+  return BigInt(`0x${hex}`);
+}
+
+export function base64Encode(str: string): string {
+  return Uint8ArrayToBase64(stringToUint8Array(str));
+}
+
+export function base64Decode(str: string): string {
+  return Uint8ArrayToString(base64ToUint8Array(str));
+}
+
+/**
+ * Constant-time equality comparison for Uint8Arrays
+ * Prevents timing attacks by always comparing all bytes
+ */
+export function uint8ArrayEqual(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+
+  let result = 0;
+  for (let i = 0; i < a.byteLength; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}

package/src/errors.ts

@@ -0,0 +1,82 @@
+/*
+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);
+  }
+}

package/src/index.browser.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+import { SigstoreVerifier } from "./sigstore.js";
+
+describe("Sigstore Browser Integration Tests", () => {
+  it("should initialize SigstoreVerifier in browser", () => {
+    const verifier = new SigstoreVerifier();
+    expect(verifier).toBeDefined();
+    expect(verifier).toBeInstanceOf(SigstoreVerifier);
+  });
+
+  it("should have crypto.subtle available for ECDSA P-256 verification", async () => {
+    expect(globalThis.crypto).toBeDefined();
+    expect(globalThis.crypto.subtle).toBeDefined();
+
+    // Test ECDSA P-256 which is what Sigstore uses
+    const keyPair = await crypto.subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: "P-256",
+      },
+      true,
+      ["sign", "verify"]
+    );
+
+    const data = new TextEncoder().encode("test");
+    const signature = await crypto.subtle.sign(
+      { name: "ECDSA", hash: "SHA-256" },
+      keyPair.privateKey,
+      data
+    );
+
+    const valid = await crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      keyPair.publicKey,
+      signature,
+      data
+    );
+
+    expect(valid).toBe(true);
+  });
+
+  it("should have crypto.subtle available for ECDSA P-384 verification", async () => {
+    // Test ECDSA P-384 which is also used by Sigstore
+    const keyPair = await crypto.subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: "P-384",
+      },
+      true,
+      ["sign", "verify"]
+    );
+
+    const data = new TextEncoder().encode("test");
+    const signature = await crypto.subtle.sign(
+      { name: "ECDSA", hash: "SHA-384" },
+      keyPair.privateKey,
+      data
+    );
+
+    const valid = await crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-384" },
+      keyPair.publicKey,
+      signature,
+      data
+    );
+
+    expect(valid).toBe(true);
+  });
+
+  it("should support SHA-256 hashing in browser", async () => {
+    const data = new TextEncoder().encode("test data");
+    const hash = await crypto.subtle.digest("SHA-256", data);
+
+    expect(hash).toBeInstanceOf(ArrayBuffer);
+    expect(hash.byteLength).toBe(32);
+  });
+
+  it("should support SHA-384 hashing in browser", async () => {
+    const data = new TextEncoder().encode("test data");
+    const hash = await crypto.subtle.digest("SHA-384", data);
+
+    expect(hash).toBeInstanceOf(ArrayBuffer);
+    expect(hash.byteLength).toBe(48);
+  });
+
+  it("should support SHA-512 hashing in browser", async () => {
+    const data = new TextEncoder().encode("test data");
+    const hash = await crypto.subtle.digest("SHA-512", data);
+
+    expect(hash).toBeInstanceOf(ArrayBuffer);
+    expect(hash.byteLength).toBe(64);
+  });
+
+  it("should support X.509 certificate key import (SPKI format)", async () => {
+    const keyPair = await crypto.subtle.generateKey(
+      {
+        name: "ECDSA",
+        namedCurve: "P-256",
+      },
+      true,
+      ["sign", "verify"]
+    );
+
+    const exported = await crypto.subtle.exportKey("spki", keyPair.publicKey);
+    const imported = await crypto.subtle.importKey(
+      "spki",
+      exported,
+      { name: "ECDSA", namedCurve: "P-256" },
+      true,
+      ["verify"]
+    );
+
+    expect(imported).toBeDefined();
+    expect(imported.type).toBe("public");
+  });
+
+  it("should support RSA-PSS for signature verification", async () => {
+    const keyPair = await crypto.subtle.generateKey(
+      {
+        name: "RSA-PSS",
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: "SHA-256",
+      },
+      true,
+      ["sign", "verify"]
+    );
+
+    const data = new TextEncoder().encode("test");
+    const signature = await crypto.subtle.sign(
+      {
+        name: "RSA-PSS",
+        saltLength: 32,
+      },
+      keyPair.privateKey,
+      data
+    );
+
+    const valid = await crypto.subtle.verify(
+      {
+        name: "RSA-PSS",
+        saltLength: 32,
+      },
+      keyPair.publicKey,
+      signature,
+      data
+    );
+
+    expect(valid).toBe(true);
+  });
+
+  it("should support TextEncoder/TextDecoder for UTF-8", () => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+
+    const text = "Hello Sigstore 🔐";
+    const encoded = encoder.encode(text);
+    const decoded = decoder.decode(encoded);
+
+    expect(decoded).toBe(text);
+    expect(encoded).toBeInstanceOf(Uint8Array);
+  });
+
+  it("should support base64 encoding/decoding (atob/btoa)", () => {
+    const text = "Hello Sigstore";
+    const base64 = btoa(text);
+    const decoded = atob(base64);
+
+    expect(decoded).toBe(text);
+    expect(base64).toBe("SGVsbG8gU2lnc3RvcmU=");
+  });
+
+  it("should support Uint8Array operations", () => {
+    const arr1 = new Uint8Array([1, 2, 3, 4, 5]);
+    const arr2 = new Uint8Array([6, 7, 8, 9, 10]);
+
+    const combined = new Uint8Array(arr1.length + arr2.length);
+    combined.set(arr1, 0);
+    combined.set(arr2, arr1.length);
+
+    expect(combined.length).toBe(10);
+    expect(combined[0]).toBe(1);
+    expect(combined[5]).toBe(6);
+  });
+
+  it("should support ArrayBuffer operations", () => {
+    const buffer = new ArrayBuffer(32);
+    const view = new Uint8Array(buffer);
+
+    view[0] = 255;
+    view[31] = 128;
+
+    expect(buffer.byteLength).toBe(32);
+    expect(view[0]).toBe(255);
+    expect(view[31]).toBe(128);
+  });
+
+  it("should support DataView for byte manipulation", () => {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+
+    view.setUint32(0, 0x12345678, false); // big-endian
+    view.setUint32(4, 0x9abcdef0, false);
+
+    expect(view.getUint32(0, false)).toBe(0x12345678);
+    expect(view.getUint8(0)).toBe(0x12);
+    expect(view.getUint8(1)).toBe(0x34);
+  });
+
+  it("should support JSON parsing of complex structures", () => {
+    const json = '{"mediaType":"application/vnd.dev.sigstore.bundle+json;version=0.3","verificationMaterial":{"tlogEntries":[{"logIndex":"123"}]}}';
+    const parsed = JSON.parse(json);
+
+    expect(parsed.mediaType).toBeDefined();
+    expect(parsed.verificationMaterial).toBeDefined();
+    expect(parsed.verificationMaterial.tlogEntries).toBeInstanceOf(Array);
+    expect(parsed.verificationMaterial.tlogEntries[0].logIndex).toBe("123");
+  });
+});

package/src/index.ts

@@ -0,0 +1,14 @@
+export { SigstoreVerifier } from "./sigstore.js";
+export type { SigstoreVerifierOptions } from "./sigstore.js";
+export type { SigstoreBundle, TLogEntry, VerificationMaterial, MessageSignature, TimestampVerificationData, RFC3161Timestamp } from "./bundle.js";
+export type { TrustedRoot, Sigstore, RawTimestampAuthority } from "./interfaces.js";
+export {
+  VerificationError,
+  TimestampError,
+  CertificateError,
+  TLogError,
+  SignatureError,
+  PolicyError,
+} from "./errors.js";
+export { verifyRFC3161Timestamp, verifyBundleTimestamp } from "./timestamp/tsa.js";
+export { TrustedRootProvider, type TrustedRootProviderOptions } from "./trust/tuf.js";

package/src/interfaces.ts

@@ -0,0 +1,118 @@
+import { X509Certificate } from "./x509/index.js";
+
+export enum SigstoreRoots {
+  certificateAuthorities = "certificateAuthorities",
+  ctlogs = "ctlogs",
+  timestampAuthorities = "timestampAuthorities",
+  tlogs = "tlogs",
+}
+
+export type RawTimestampAuthorities = RawTimestampAuthority[];
+
+export interface TrustedRoot {
+  mediaType: string;
+  tlogs: RawLogs;
+  certificateAuthorities: RawCAs;
+  ctlogs: RawLogs;
+  timestampAuthorities: RawTimestampAuthorities;
+}
+
+export interface RawTimestampAuthority {
+  subject: {
+    organization: string;
+    commonName: string;
+  };
+  certChain: {
+    certificates: {
+      rawBytes: string;
+    }[];
+  };
+  validFor: {
+    start: string;
+    end?: string;
+  };
+}
+
+export interface CTLog {
+  logID: Uint8Array;
+  publicKey: CryptoKey;
+  validFor: {
+    start: Date;
+    end: Date;
+  };
+}
+
+export interface RekorKeyInfo {
+  publicKey: CryptoKey;
+  logId: Uint8Array;
+}
+
+export interface CertAuthority {
+  certChain: X509Certificate[];
+  validFor: {
+    start: Date;
+    end: Date;
+  };
+}
+
+export interface Sigstore {
+  rekor: RekorKeyInfo | undefined;
+  ctlogs: CTLog[];
+  certificateAuthorities: CertAuthority[];
+  timestampAuthorities: CertAuthority[];
+}
+
+export interface RawLog {
+  baseUrl: string;
+  hashAlgorithm: string;
+  publicKey: {
+    rawBytes: string;
+    keyDetails: string;
+    validFor: {
+      start: string;
+      end?: string;
+    };
+  };
+  logId: {
+    keyId: string;
+  };
+}
+
+export type RawLogs = RawLog[];
+
+export interface RawCA {
+  subject: {
+    organization: string;
+    commonName: string;
+  };
+  uri: string;
+  certChain: {
+    certificates: {
+      rawBytes: string;
+    }[];
+  };
+  validFor: {
+    start: string;
+    end?: string;
+  };
+}
+
+export type RawCAs = RawCA[];
+
+export enum KeyTypes {
+  Ecdsa = "ECDSA",
+  Ed25519 = "Ed25519",
+  RSA = "RSA",
+}
+
+export enum EcdsaTypes {
+  P256 = "P-256",
+  P384 = "P-384",
+  P521 = "P-521",
+}
+
+export enum HashAlgorithms {
+  SHA256 = "SHA-256",
+  SHA384 = "SHA-384",
+  SHA512 = "SHA-512",
+}

package/src/oid.ts

@@ -0,0 +1,28 @@
+// From https://github.com/sigstore/sigstore-js/blob/main/packages/core/src/oid.ts
+
+export const ECDSA_SIGNATURE_ALGOS: Record<string, string> = {
+  "1.2.840.10045.4.3.1": "sha224",
+  "1.2.840.10045.4.3.2": "sha256",
+  "1.2.840.10045.4.3.3": "sha384",
+  "1.2.840.10045.4.3.4": "sha512",
+};
+
+// RSA signature algorithms
+export const RSA_SIGNATURE_ALGOS: Record<string, string> = {
+  "1.2.840.113549.1.1.11": "sha256", // sha256WithRSAEncryption
+  "1.2.840.113549.1.1.12": "sha384", // sha384WithRSAEncryption
+  "1.2.840.113549.1.1.13": "sha512", // sha512WithRSAEncryption
+  "1.2.840.113549.1.1.5": "sha1",    // sha1WithRSAEncryption
+};
+
+export const SHA2_HASH_ALGOS: Record<string, string> = {
+  "2.16.840.1.101.3.4.2.1": "sha256",
+  "2.16.840.1.101.3.4.2.2": "sha384",
+  "2.16.840.1.101.3.4.2.3": "sha512",
+};
+
+export const ECDSA_CURVE_NAMES: Record<string, string> = {
+  "1.2.840.10045.3.1.7": "secp256r1",
+  "1.3.132.0.34": "secp384r1",
+  "1.3.132.0.35": "secp521r1",
+};

package/src/pem.ts

@@ -0,0 +1,48 @@
+/*
+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.
+*/
+
+import { base64ToUint8Array, Uint8ArrayToBase64 } from "./encoding.js";
+
+const PEM_HEADER = /-----BEGIN (.*)-----/;
+const PEM_FOOTER = /-----END (.*)-----/;
+
+export function toDER(certificate: string): Uint8Array {
+  let der = "";
+
+  certificate.split("\n").forEach((line) => {
+    if (line.match(PEM_HEADER) || line.match(PEM_FOOTER)) {
+      return;
+    }
+
+    der += line;
+  });
+
+  return base64ToUint8Array(der);
+}
+
+// Translates a DER-encoded buffer into a PEM-encoded string. Standard PEM
+// encoding dictates that each certificate should have a trailing newline after
+// the footer.
+export function fromDER(certificate: Uint8Array, type = "CERTIFICATE"): string {
+  // Base64-encode the certificate.
+  const der = Uint8ArrayToBase64(certificate);
+  // Split the certificate into lines of 64 characters.
+  const lines = der.match(/.{1,64}/g) || "";
+
+  return [`-----BEGIN ${type}-----`, ...lines, `-----END ${type}-----`]
+    .join("\n")
+    .concat("\n");
+}

package/src/rfc3161/error.ts

@@ -0,0 +1,16 @@
+/*
+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.
+*/
+export class RFC3161TimestampVerificationError extends Error {}

package/src/rfc3161/index.ts

@@ -0,0 +1,17 @@
+/*
+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.
+*/
+
+export { RFC3161Timestamp } from "./timestamp.js";