@freedomofpress/sigstore-browser 0.1.0 → 0.1.2

package/src/crypto.ts

@@ -1,310 +0,0 @@
-import { ASN1Obj } from "./asn1/index.js";
-import {
-  base64ToUint8Array,
-  base64UrlToUint8Array,
-  hexToUint8Array,
-  toArrayBuffer,
-  Uint8ArrayToHex,
-} from "./encoding.js";
-import { EcdsaTypes, HashAlgorithms, KeyTypes } from "./interfaces.js";
-import { toDER } from "./pem.js";
-import { p256, p384, p521 } from "@noble/curves/nist.js";
-
-function pkcs1ToSpki(pkcs1Bytes: Uint8Array): Uint8Array {
-  const algorithmIdentifier = new Uint8Array([
-    0x30, 0x0d,
-    0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
-    0x05, 0x00
-  ]);
-
-  const bitStringLength = pkcs1Bytes.length + 1;
-  const totalContentLength = algorithmIdentifier.length + 1 + lengthBytes(bitStringLength).length + bitStringLength;
-
-  const result = new Uint8Array(1 + lengthBytes(totalContentLength).length + totalContentLength);
-  let offset = 0;
-
-  result[offset++] = 0x30;
-  const totalLengthBytes = lengthBytes(totalContentLength);
-  result.set(totalLengthBytes, offset);
-  offset += totalLengthBytes.length;
-
-  result.set(algorithmIdentifier, offset);
-  offset += algorithmIdentifier.length;
-
-  result[offset++] = 0x03;
-  const bitStringLengthBytes = lengthBytes(bitStringLength);
-  result.set(bitStringLengthBytes, offset);
-  offset += bitStringLengthBytes.length;
-  result[offset++] = 0x00;
-  result.set(pkcs1Bytes, offset);
-
-  return result;
-}
-
-// Encodes a length value in DER (Distinguished Encoding Rules) format.
-// DER length encoding rules:
-// - Lengths 0-127: single byte containing the length
-// - Lengths 128-255: 0x81 followed by one byte containing the length
-// - Lengths 256-65535: 0x82 followed by two bytes containing the length (big-endian)
-// Used by pkcs1ToSpki() to construct valid ASN.1/DER structures.
-function lengthBytes(length: number): Uint8Array {
-  if (length < 128) {
-    return new Uint8Array([length]);
-  } else if (length < 256) {
-    return new Uint8Array([0x81, length]);
-  } else {
-    return new Uint8Array([0x82, (length >> 8) & 0xff, length & 0xff]);
-  }
-}
-
-// Imports cryptographic public keys into the Web Crypto API format (CryptoKey).
-// This function is specific to the browser implementation and doesn't exist in sigstore-js.
-//
-// Why needed for browser:
-// - sigstore-js uses Node.js crypto.createPublicKey() which handles many key formats automatically
-// - Browsers only have Web Crypto API (crypto.subtle.importKey) which requires explicit format/algorithm
-// - This function bridges the gap by:
-//   1. Detecting key format (PEM, hex, base64, PKCS#1, SPKI)
-//   2. Converting PKCS#1 RSA keys to SPKI (Web Crypto only supports SPKI for RSA)
-//   3. Mapping Sigstore key types/schemes to Web Crypto algorithm parameters
-//
-// Supports:
-// - ECDSA (P-256, P-384, P-521) - Used by Fulcio, CT logs
-// - Ed25519 - Used by Rekor checkpoints, some CT logs
-// - RSA (PKCS#1, PSS) - Used by older CT logs and some Rekor instances
-//
-// Key format detection:
-// - PEM format (contains "BEGIN"): Parse with toDER()
-// - Hex string (all hex chars): Import as raw
-// - Base64 PKCS#1 (starts with 0x30 0x82...): Convert to SPKI
-// - Base64 SPKI: Import directly
-export async function importKey(
-  keytype: string,
-  scheme: string,
-  key: string,
-): Promise<CryptoKey> {
-  class importParams {
-    format: "raw" | "spki" = "spki";
-    keyData: ArrayBuffer = new ArrayBuffer(0);
-    algorithm: RsaHashedImportParams | EcKeyImportParams | Algorithm = { name: "ECDSA" };
-    extractable: boolean = true;
-    usage: Array<KeyUsage> = ["verify"];
-  }
-
-  const params = new importParams();
-  if (key.includes("BEGIN")) {
-    params.format = "spki";
-    params.keyData = toArrayBuffer(toDER(key));
-  } else if (/^[0-9A-Fa-f]+$/.test(key)) {
-    params.format = "raw";
-    params.keyData = toArrayBuffer(hexToUint8Array(key));
-  } else {
-    params.format = "spki";
-    const keyBytes = base64ToUint8Array(key);
-
-    if (keytype.toLowerCase().includes("pkcs1") &&
-        keyBytes[0] === 0x30 && keyBytes[1] === 0x82 &&
-        keyBytes[4] === 0x02 && keyBytes[5] === 0x82) {
-      params.keyData = toArrayBuffer(pkcs1ToSpki(keyBytes));
-    } else {
-      params.keyData = toArrayBuffer(keyBytes);
-    }
-  }
-
-  if (keytype.toLowerCase().includes("ecdsa")) {
-    if (scheme.includes("256")) {
-      params.algorithm = { name: "ECDSA", namedCurve: EcdsaTypes.P256 };
-    } else if (scheme.includes("384")) {
-      params.algorithm = { name: "ECDSA", namedCurve: EcdsaTypes.P384 };
-    } else if (scheme.includes("521")) {
-      params.algorithm = { name: "ECDSA", namedCurve: EcdsaTypes.P521 };
-    } else {
-      throw new Error("Cannot determine ECDSA key size.");
-    }
-  } else if (keytype.toLowerCase().includes("ed25519")) {
-    params.algorithm = { name: "Ed25519" };
-  } else if (keytype.toLowerCase().includes("rsa") || keytype.toLowerCase().includes("pkcs1")) {
-    let hashName = HashAlgorithms.SHA256;
-    // Normalize scheme to handle various formats: SHA256, SHA_256, SHA-256, etc.
-    const normalizedScheme = scheme.toUpperCase().replace(/[-_]/g, "");
-    if (normalizedScheme.includes("SHA256") || normalizedScheme.includes("256")) {
-      hashName = HashAlgorithms.SHA256;
-    } else if (normalizedScheme.includes("SHA384") || normalizedScheme.includes("384")) {
-      hashName = HashAlgorithms.SHA384;
-    } else if (normalizedScheme.includes("SHA512") || normalizedScheme.includes("512")) {
-      hashName = HashAlgorithms.SHA512;
-    }
-
-    if (scheme.includes("PKCS1") || scheme.includes("RSA_PKCS1")) {
-      params.algorithm = {
-        name: "RSASSA-PKCS1-v1_5",
-        hash: { name: hashName },
-      };
-    } else {
-      params.algorithm = {
-        name: "RSA-PSS",
-        hash: { name: hashName },
-      };
-    }
-  } else {
-    throw new Error(`Unsupported ${keytype}`);
-  }
-
-  return await crypto.subtle.importKey(
-    params.format,
-    params.keyData,
-    params.algorithm,
-    params.extractable,
-    params.usage,
-  );
-}
-
-export async function verifySignature(
-  key: CryptoKey,
-  signed: Uint8Array,
-  sig: Uint8Array,
-  hash: string = "sha256",
-): Promise<boolean> {
-  const options: {
-    name: string;
-    hash?: {
-      name: string;
-    };
-  } = {
-    name: key.algorithm.name,
-  };
-
-  if (key.algorithm.name === KeyTypes.Ecdsa) {
-    const namedCurve = (key.algorithm as EcKeyAlgorithm).namedCurve;
-    let sig_size = 32;
-
-    if (namedCurve === EcdsaTypes.P256) {
-      sig_size = 32;
-    } else if (namedCurve === EcdsaTypes.P384) {
-      sig_size = 48;
-    } else if (namedCurve === EcdsaTypes.P521) {
-      sig_size = 66;
-    }
-
-    options.hash = { name: "" };
-    if (hash.includes("256")) {
-      options.hash.name = HashAlgorithms.SHA256;
-    } else if (hash.includes("384")) {
-      options.hash.name = HashAlgorithms.SHA384;
-    } else if (hash.includes("512")) {
-      options.hash.name = HashAlgorithms.SHA512;
-    } else {
-      throw new Error("Cannot determine hashing algorithm;");
-    }
-
-    let raw_signature: Uint8Array;
-    try {
-      const asn1_sig = ASN1Obj.parseBuffer(sig);
-      const r = asn1_sig.subs[0].toInteger();
-      const s = asn1_sig.subs[1].toInteger();
-      const binr = hexToUint8Array(r.toString(16).padStart(sig_size * 2, "0"));
-      const bins = hexToUint8Array(s.toString(16).padStart(sig_size * 2, "0"));
-      raw_signature = new Uint8Array(binr.length + bins.length);
-      raw_signature.set(binr, 0);
-      raw_signature.set(bins, binr.length);
-    } catch {
-      return false;
-    }
-
-    return await crypto.subtle.verify(
-      options,
-      key,
-      toArrayBuffer(raw_signature),
-      toArrayBuffer(signed),
-    );
-  } else if (key.algorithm.name === KeyTypes.Ed25519) {
-    // Ed25519 uses raw signatures (not DER-encoded like ECDSA)
-    // Fulcio supports Ed25519, ECDSA, and RSA_PSS for signing certificates
-    // Ed25519 is also used for checkpoint signatures in TLog configurations
-    return await crypto.subtle.verify(
-      key.algorithm.name,
-      key,
-      toArrayBuffer(sig),
-      toArrayBuffer(signed),
-    );
-  } else if (key.algorithm.name === "RSA-PSS") {
-    // Salt length must match the hash output size
-    const hashAlg = (key.algorithm as RsaHashedKeyAlgorithm).hash.name;
-    const saltLength = hashAlg === HashAlgorithms.SHA256 ? 32 :
-                       hashAlg === HashAlgorithms.SHA384 ? 48 :
-                       hashAlg === HashAlgorithms.SHA512 ? 64 : 32;
-    return await crypto.subtle.verify(
-      {
-        name: "RSA-PSS",
-        saltLength: saltLength,
-      },
-      key,
-      toArrayBuffer(sig),
-      toArrayBuffer(signed),
-    );
-  } else if (key.algorithm.name === "RSASSA-PKCS1-v1_5") {
-    return await crypto.subtle.verify(
-      key.algorithm.name,
-      key,
-      toArrayBuffer(sig),
-      toArrayBuffer(signed),
-    );
-  } else {
-    throw new Error("Unsupported key type!");
-  }
-}
-
-// Verifies an ECDSA signature over a pre-computed digest.
-// WebCrypto's verify() always hashes the input first, so passing a digest would
-// result in double-hashing. We use @noble/curves for low-level ECDSA verification,
-// adapted from the same workaround used in sigstore-js's conformance CLI.
-// See: https://github.com/sigstore/sigstore-js/blob/main/packages/conformance/src/commands/verify-bundle.ts#L111
-export async function verifySignatureOverDigest(
-  key: CryptoKey,
-  digest: Uint8Array,
-  sig: Uint8Array,
-): Promise<boolean> {
-  if (key.algorithm.name !== KeyTypes.Ecdsa) {
-    throw new Error("verifySignatureOverDigest only supports ECDSA keys");
-  }
-
-  const namedCurve = (key.algorithm as EcKeyAlgorithm).namedCurve;
-  let curve: typeof p256 | typeof p384 | typeof p521;
-
-  if (namedCurve === EcdsaTypes.P256) {
-    curve = p256;
-  } else if (namedCurve === EcdsaTypes.P384) {
-    curve = p384;
-  } else if (namedCurve === EcdsaTypes.P521) {
-    curve = p521;
-  } else {
-    throw new Error(`Unsupported curve: ${namedCurve}`);
-  }
-
-  // Export the public key to get x and y coordinates
-  const jwk = await crypto.subtle.exportKey("jwk", key);
-  if (!jwk.x || !jwk.y) {
-    throw new Error("Invalid ECDSA public key: missing x or y coordinates");
-  }
-
-  // Convert base64url JWK coordinates to bytes
-  const x = base64UrlToUint8Array(jwk.x);
-  const y = base64UrlToUint8Array(jwk.y);
-
-  // Combine x and y into uncompressed public key format (0x04 || x || y)
-  const publicKey = new Uint8Array(1 + x.length + y.length);
-  publicKey[0] = 0x04;
-  publicKey.set(x, 1);
-  publicKey.set(y, 1 + x.length);
-
-  // Verify the DER-encoded signature over the digest
-  // @noble/curves can parse DER signatures directly with format: 'der'
-  // Options:
-  // - format: 'der' to parse DER-encoded signatures
-  // - prehash: false because we're passing a pre-computed digest, not the original message
-  // - lowS: false to accept both high-S and low-S signatures (matches elliptic.js behavior)
-  //   elliptic.js accepts malleable signatures by default, while @noble/curves rejects them by default
-  return curve.verify(sig, digest, publicKey, { format: 'der', prehash: false, lowS: false });
-}
-
-export { uint8ArrayEqual as bufferEqual } from "./encoding.js";

package/src/encoding.ts

@@ -1,141 +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.
-*/
-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/pem.ts

@@ -1,48 +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.
-*/
-
-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/stream.ts

@@ -1,141 +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.
-*/
-class StreamError extends Error {}
-
-export class ByteStream {
-  private static BLOCK_SIZE = 1024;
-
-  private buf: ArrayBuffer;
-  private view: Uint8Array;
-  private start = 0;
-
-  constructor(buffer?: ArrayBuffer) {
-    if (buffer) {
-      this.buf = buffer;
-      this.view = new Uint8Array(buffer);
-    } else {
-      this.buf = new ArrayBuffer(0);
-      this.view = new Uint8Array(this.buf);
-    }
-  }
-
-  get buffer(): Uint8Array {
-    return this.view.subarray(0, this.start);
-  }
-
-  get length(): number {
-    return this.view.byteLength;
-  }
-
-  get position(): number {
-    return this.start;
-  }
-
-  public seek(position: number) {
-    this.start = position;
-  }
-
-  // Returns a Buffer containing the specified number of bytes starting at the
-  // given start position.
-  public slice(start: number, len: number): Uint8Array {
-    const end = start + len;
-
-    if (end > this.length) {
-      throw new StreamError("request past end of buffer");
-    }
-
-    return this.view.subarray(start, end);
-  }
-
-  public appendChar(char: number) {
-    this.ensureCapacity(1);
-    this.view[this.start] = char;
-    this.start += 1;
-  }
-
-  public appendUint16(num: number) {
-    this.ensureCapacity(2);
-
-    const value = new Uint16Array([num]);
-    const view = new Uint8Array(value.buffer);
-
-    this.view[this.start] = view[1];
-    this.view[this.start + 1] = view[0];
-    this.start += 2;
-  }
-
-  public appendUint24(num: number) {
-    this.ensureCapacity(3);
-
-    const value = new Uint32Array([num]);
-    const view = new Uint8Array(value.buffer);
-
-    this.view[this.start] = view[2];
-    this.view[this.start + 1] = view[1];
-    this.view[this.start + 2] = view[0];
-    this.start += 3;
-  }
-
-  public appendView(view: Uint8Array) {
-    this.ensureCapacity(view.length);
-    this.view.set(view, this.start);
-    this.start += view.length;
-  }
-
-  public getBlock(size: number): Uint8Array {
-    if (size <= 0) {
-      return new Uint8Array(0);
-    }
-
-    if (this.start + size > this.view.length) {
-      throw new Error("request past end of buffer");
-    }
-
-    const result = this.view.subarray(this.start, this.start + size);
-    this.start += size;
-
-    return result;
-  }
-
-  public getUint8(): number {
-    return this.getBlock(1)[0];
-  }
-
-  public getUint16(): number {
-    const block = this.getBlock(2);
-
-    return (block[0] << 8) | block[1];
-  }
-
-  private ensureCapacity(size: number) {
-    if (this.start + size > this.view.byteLength) {
-      const blockSize =
-        ByteStream.BLOCK_SIZE + (size > ByteStream.BLOCK_SIZE ? size : 0);
-      this.realloc(this.view.byteLength + blockSize);
-    }
-  }
-
-  private realloc(size: number) {
-    const newArray = new ArrayBuffer(size);
-    const newView = new Uint8Array(newArray);
-
-    // Copy the old buffer into the new one
-    newView.set(this.view);
-
-    this.buf = newArray;
-    this.view = newView;
-  }
-}

package/src/types/tuf-browser.d.ts

@@ -1,13 +0,0 @@
-declare module 'tuf-browser/dist/tuf.js' {
-  export class TUFClient {
-    constructor(
-      repositoryUrl: string,
-      startingRoot: string,
-      namespace: string,
-      targetBaseUrl?: string
-    );
-
-    updateTUF(): Promise<void>;
-    getTarget(targetPath: string): Promise<Uint8Array>;
-  }
-}