@blockcast/mmt-container 0.3.0 → 0.4.0-main.d6f2737828fc

package/node_modules/@blockcast/mmt-manifest-verify/package.json

@@ -1,45 +0,0 @@
-{
-  "name": "@blockcast/mmt-manifest-verify",
-  "version": "0.3.0",
-  "description": "Canonical live MMT source-auth manifest verifier",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src",
-    "!src/**/*.test.ts",
-    "!src/**/*.spec.ts",
-    "!src/**/__tests__",
-    "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "clean": "rm -rf dist",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "dependencies": {
-    "@noble/hashes": "^1.8.0"
-  },
-  "devDependencies": {
-    "@blockcast/mmt-fec": "file:../fec",
-    "typescript": "^5.3.0",
-    "vitest": "^1.0.0"
-  },
-  "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Blockcast/libmmt.git",
-    "directory": "packages/mmt-manifest-verify"
-  }
-}

package/node_modules/@blockcast/mmt-manifest-verify/src/admission.ts

@@ -1,171 +0,0 @@
-import {
-  sourceAuthMerkleRoot,
-  sourceAuthObjectDigest,
-  sourceAuthSignaturePreimage,
-  trimRecoveredSourceAuthObject,
-  type SourceAuthGroupClose,
-  type SourceAuthObjectEntry,
-} from './source-auth.js'
-
-export type SourceAuthAdmissionState =
-  | 'pending-entry'
-  | 'pending-object'
-  | 'provisional'
-  | 'authenticated'
-
-export interface SourceAuthObjectAdmission {
-  groupId: bigint
-  objectId: number
-  recovered: boolean
-  state: Exclude<SourceAuthAdmissionState, 'pending-object'>
-}
-
-interface PendingSourceAuthObject {
-  bytes: Uint8Array
-  recovered: boolean
-}
-
-function requireU64(name: string, value: bigint): void {
-  if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
-    throw new Error(`${name} must be an unsigned 64-bit integer`)
-  }
-}
-
-function equalBytes(left: Uint8Array, right: Uint8Array): boolean {
-  if (left.byteLength !== right.byteLength) return false
-  return left.every((value, index) => value === right[index])
-}
-
-/**
- * Bounded media/manifest rendezvous for the browser player receive path.
- * Object digest admission is synchronous; only the group-close signature is deferred.
- */
-export class SourceAuthAdmission {
-  readonly #manifestAuthenticated: boolean
-  readonly #entries = new Map<number, SourceAuthObjectEntry>()
-  readonly #pendingObjects = new Map<number, PendingSourceAuthObject>()
-  readonly #entriesAwaitingObjects = new Set<number>()
-  readonly #admissions = new Map<number, SourceAuthObjectAdmission>()
-  #groupId: bigint | null = null
-  #closed = false
-
-  constructor(options: { manifestAuthenticated: boolean }) {
-    this.#manifestAuthenticated = options.manifestAuthenticated
-  }
-
-  admitObject(input: {
-    groupId: bigint
-    objectId: number
-    bytes: Uint8Array
-    recovered?: boolean
-  }): SourceAuthObjectAdmission {
-    this.#requireGroup(input.groupId)
-    if (this.#closed) throw new Error('source-auth group is already closed')
-    if (this.#admissions.has(input.objectId) || this.#pendingObjects.has(input.objectId)) {
-      throw new Error(`duplicate source-auth object ${input.objectId}`)
-    }
-    const entry = this.#entries.get(input.objectId)
-    if (entry) {
-      this.#entriesAwaitingObjects.delete(input.objectId)
-      return this.#verifyObject(entry, input.bytes, input.recovered ?? false)
-    }
-    if (this.#pendingObjects.size >= 1) {
-      throw new Error('source-auth media exceeds one-object manifest skew')
-    }
-    this.#pendingObjects.set(input.objectId, {
-      bytes: input.bytes,
-      recovered: input.recovered ?? false,
-    })
-    return {
-      groupId: input.groupId,
-      objectId: input.objectId,
-      recovered: input.recovered ?? false,
-      state: 'pending-entry',
-    }
-  }
-
-  admitEntry(entry: SourceAuthObjectEntry): SourceAuthObjectAdmission | SourceAuthAdmissionState {
-    this.#requireGroup(entry.groupId)
-    if (this.#closed) throw new Error('source-auth group is already closed')
-    if (this.#entries.has(entry.objectId)) {
-      throw new Error(`duplicate source-auth manifest entry ${entry.objectId}`)
-    }
-    const pending = this.#pendingObjects.get(entry.objectId)
-    if (!pending && this.#entriesAwaitingObjects.size >= 1) {
-      throw new Error('source-auth manifest exceeds one-object media skew')
-    }
-    this.#entries.set(entry.objectId, entry)
-    if (!pending) {
-      this.#entriesAwaitingObjects.add(entry.objectId)
-      return 'pending-object'
-    }
-    this.#pendingObjects.delete(entry.objectId)
-    return this.#verifyObject(entry, pending.bytes, pending.recovered)
-  }
-
-  objectState(objectId: number): SourceAuthAdmissionState | undefined {
-    if (this.#pendingObjects.has(objectId)) return 'pending-entry'
-    if (this.#entriesAwaitingObjects.has(objectId)) return 'pending-object'
-    if (this.#closed && this.#admissions.has(objectId)) return 'authenticated'
-    return this.#admissions.get(objectId)?.state
-  }
-
-  async verifyClose(
-    close: SourceAuthGroupClose,
-    authScope: Uint8Array,
-    publicKey: CryptoKey,
-    subtle: SubtleCrypto = globalThis.crypto.subtle,
-  ): Promise<void> {
-    this.#requireGroup(close.groupId)
-    if (this.#closed) throw new Error('source-auth group is already closed')
-    if (this.#pendingObjects.size !== 0 || this.#entriesAwaitingObjects.size !== 0) {
-      throw new Error('source-auth group closed with unmatched objects or entries')
-    }
-    if (close.objectCount !== this.#entries.size || this.#admissions.size !== this.#entries.size) {
-      throw new Error('source-auth group close object count mismatch')
-    }
-    const root = sourceAuthMerkleRoot([...this.#entries.values()])
-    if (!equalBytes(root, close.root)) throw new Error('source-auth group root mismatch')
-    const verified = await subtle.verify(
-      'Ed25519',
-      publicKey,
-      new Uint8Array(close.signature).buffer,
-      new Uint8Array(
-        sourceAuthSignaturePreimage(authScope, close.groupId, close.objectCount, root),
-      ).buffer,
-    )
-    if (!verified) throw new Error('source-auth group close signature failed')
-    for (const admission of this.#admissions.values()) admission.state = 'authenticated'
-    this.#closed = true
-  }
-
-  #requireGroup(groupId: bigint): void {
-    requireU64('groupId', groupId)
-    if (this.#groupId === null) this.#groupId = groupId
-    else if (this.#groupId !== groupId) throw new Error('source-auth group identity mismatch')
-  }
-
-  #verifyObject(
-    entry: SourceAuthObjectEntry,
-    bytes: Uint8Array,
-    recovered: boolean,
-  ): SourceAuthObjectAdmission {
-    const authenticated = recovered
-      ? trimRecoveredSourceAuthObject(bytes, entry.trueLength)
-      : bytes
-    if (!recovered && bytes.byteLength !== entry.trueLength) {
-      throw new Error(`direct source-auth object length mismatch for ${entry.objectId}`)
-    }
-    if (!equalBytes(sourceAuthObjectDigest(authenticated), entry.digest)) {
-      throw new Error(`source-auth object digest mismatch for ${entry.objectId}`)
-    }
-    const admission: SourceAuthObjectAdmission = {
-      groupId: entry.groupId,
-      objectId: entry.objectId,
-      recovered,
-      state: this.#manifestAuthenticated ? 'authenticated' : 'provisional',
-    }
-    this.#admissions.set(entry.objectId, admission)
-    return admission
-  }
-}

package/node_modules/@blockcast/mmt-manifest-verify/src/index.ts

@@ -1,3 +0,0 @@
-export * from './source-auth.js'
-export * from './admission.js'
-export * from './verifier.js'

package/node_modules/@blockcast/mmt-manifest-verify/src/source-auth.ts

@@ -1,230 +0,0 @@
-import { blake3 } from '@noble/hashes/blake3'
-
-export const SOURCE_AUTH_MANIFEST_VERSION = 1
-export const SOURCE_AUTH_OBJECT_ENTRY_FRAME = 1
-export const SOURCE_AUTH_GROUP_CLOSE_FRAME = 2
-export const SOURCE_AUTH_OBJECT_ENTRY_LENGTH = 52
-export const SOURCE_AUTH_GROUP_CLOSE_LENGTH = 112
-export const SOURCE_AUTH_MAX_OBJECTS_PER_GROUP = 4096
-export const SOURCE_AUTH_MAX_TRUE_LENGTH = 16 * 1024 * 1024
-export const SOURCE_AUTH_SCOPE_LENGTH = 32
-
-const SIGNATURE_DOMAIN = new TextEncoder().encode('blockcast-mmt-root-v1\0\0\0')
-
-export interface SourceAuthObjectEntry {
-  kind: 'object'
-  groupId: bigint
-  objectId: number
-  trueLength: number
-  digest: Uint8Array
-}
-
-export interface SourceAuthGroupClose {
-  kind: 'close'
-  groupId: bigint
-  objectCount: number
-  root: Uint8Array
-  signature: Uint8Array
-}
-
-export type SourceAuthManifestFrame = SourceAuthObjectEntry | SourceAuthGroupClose
-
-function requireBytes(name: string, value: Uint8Array, length: number): void {
-  if (value.byteLength !== length) {
-    throw new Error(`${name} must be ${length} bytes, got ${value.byteLength}`)
-  }
-}
-
-function requireU32(name: string, value: number): void {
-  if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff) {
-    throw new Error(`${name} must be an unsigned 32-bit integer`)
-  }
-}
-
-function requireU64(name: string, value: bigint): void {
-  if (value < 0n || value > 0xffff_ffff_ffff_ffffn) {
-    throw new Error(`${name} must be an unsigned 64-bit integer`)
-  }
-}
-
-function requireTrueLength(value: number): void {
-  requireU32('trueLength', value)
-  if (value > SOURCE_AUTH_MAX_TRUE_LENGTH) {
-    throw new Error(`trueLength exceeds the ${SOURCE_AUTH_MAX_TRUE_LENGTH}-byte profile maximum`)
-  }
-}
-
-export function sourceAuthObjectDigest(object: Uint8Array): Uint8Array {
-  return blake3(object)
-}
-
-export function sourceAuthLeafHash(
-  groupId: bigint,
-  objectId: number,
-  digest: Uint8Array,
-  trueLength: number,
-): Uint8Array {
-  requireU64('groupId', groupId)
-  requireU32('objectId', objectId)
-  requireBytes('digest', digest, 32)
-  requireTrueLength(trueLength)
-  const preimage = new Uint8Array(49)
-  const view = new DataView(preimage.buffer)
-  view.setBigUint64(1, groupId)
-  view.setUint32(9, objectId)
-  preimage.set(digest, 13)
-  view.setUint32(45, trueLength)
-  return blake3(preimage)
-}
-
-export function sourceAuthMerkleRoot(
-  entries: readonly {
-    groupId: bigint
-    objectId: number
-    digest: Uint8Array
-    trueLength: number
-  }[],
-): Uint8Array {
-  if (entries.length === 0) throw new Error('Merkle tree requires at least one object')
-  if (entries.length > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
-    throw new Error(`group exceeds ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP} objects`)
-  }
-  const groupId = entries[0]!.groupId
-  const objectIds = new Set<number>()
-  const ordered = [...entries].sort((left, right) => left.objectId - right.objectId)
-  let level = ordered.map((entry) => {
-    if (entry.groupId !== groupId) throw new Error('Merkle entries must belong to one group')
-    if (objectIds.has(entry.objectId)) throw new Error(`duplicate objectId ${entry.objectId}`)
-    objectIds.add(entry.objectId)
-    return sourceAuthLeafHash(entry.groupId, entry.objectId, entry.digest, entry.trueLength)
-  })
-  while (level.length > 1) {
-    const parents: Uint8Array[] = []
-    for (let index = 0; index < level.length; index += 2) {
-      const left = level[index]!
-      const right = level[index + 1] ?? left
-      const preimage = new Uint8Array(65)
-      preimage[0] = 1
-      preimage.set(left, 1)
-      preimage.set(right, 33)
-      parents.push(blake3(preimage))
-    }
-    level = parents
-  }
-  return level[0]!
-}
-
-export function trimRecoveredSourceAuthObject(
-  recoveredSymbol: Uint8Array,
-  trueLength: number,
-): Uint8Array {
-  requireTrueLength(trueLength)
-  if (trueLength > recoveredSymbol.byteLength) {
-    throw new Error(`true length ${trueLength} exceeds recovered object size ${recoveredSymbol.byteLength}`)
-  }
-  return recoveredSymbol.subarray(0, trueLength)
-}
-
-export function encodeSourceAuthObjectEntry(
-  entry: Omit<SourceAuthObjectEntry, 'kind'>,
-): Uint8Array {
-  requireU32('objectId', entry.objectId)
-  requireTrueLength(entry.trueLength)
-  requireU64('groupId', entry.groupId)
-  requireBytes('digest', entry.digest, 32)
-  const frame = new Uint8Array(SOURCE_AUTH_OBJECT_ENTRY_LENGTH)
-  const view = new DataView(frame.buffer)
-  frame[0] = SOURCE_AUTH_OBJECT_ENTRY_FRAME
-  frame[1] = SOURCE_AUTH_MANIFEST_VERSION
-  view.setBigUint64(4, entry.groupId)
-  view.setUint32(12, entry.objectId)
-  view.setUint32(16, entry.trueLength)
-  frame.set(entry.digest, 20)
-  return frame
-}
-
-export function encodeSourceAuthGroupClose(
-  close: Omit<SourceAuthGroupClose, 'kind'>,
-): Uint8Array {
-  requireU32('objectCount', close.objectCount)
-  if (close.objectCount === 0 || close.objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
-    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`)
-  }
-  requireU64('groupId', close.groupId)
-  requireBytes('root', close.root, 32)
-  requireBytes('signature', close.signature, 64)
-  const frame = new Uint8Array(SOURCE_AUTH_GROUP_CLOSE_LENGTH)
-  const view = new DataView(frame.buffer)
-  frame[0] = SOURCE_AUTH_GROUP_CLOSE_FRAME
-  frame[1] = SOURCE_AUTH_MANIFEST_VERSION
-  view.setBigUint64(4, close.groupId)
-  view.setUint32(12, close.objectCount)
-  frame.set(close.root, 16)
-  frame.set(close.signature, 48)
-  return frame
-}
-
-export function sourceAuthSignaturePreimage(
-  authScope: Uint8Array,
-  groupId: bigint,
-  objectCount: number,
-  root: Uint8Array,
-): Uint8Array {
-  requireU32('objectCount', objectCount)
-  if (objectCount === 0 || objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
-    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`)
-  }
-  requireU64('groupId', groupId)
-  requireBytes('authScope', authScope, SOURCE_AUTH_SCOPE_LENGTH)
-  requireBytes('root', root, 32)
-  const preimage = new Uint8Array(100)
-  const view = new DataView(preimage.buffer)
-  preimage.set(SIGNATURE_DOMAIN)
-  preimage.set(authScope, 24)
-  view.setBigUint64(56, groupId)
-  view.setUint32(64, objectCount)
-  preimage.set(root, 68)
-  return preimage
-}
-
-export function decodeSourceAuthManifestFrame(frame: Uint8Array): SourceAuthManifestFrame {
-  const frameType = frame[0]
-  const expectedLength = frameType === SOURCE_AUTH_OBJECT_ENTRY_FRAME
-    ? SOURCE_AUTH_OBJECT_ENTRY_LENGTH
-    : frameType === SOURCE_AUTH_GROUP_CLOSE_FRAME
-      ? SOURCE_AUTH_GROUP_CLOSE_LENGTH
-      : 0
-  if (expectedLength === 0) throw new Error(`unsupported manifest frame type ${frameType}`)
-  if (frame.byteLength !== expectedLength) {
-    throw new Error(`manifest frame has invalid length ${frame.byteLength} for type ${frameType}`)
-  }
-  if (frame[1] !== SOURCE_AUTH_MANIFEST_VERSION) {
-    throw new Error(`unsupported manifest version ${frame[1]}`)
-  }
-  if (frame[2] !== 0 || frame[3] !== 0) throw new Error('manifest reserved bits must be zero')
-
-  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength)
-  const groupId = view.getBigUint64(4)
-  if (frameType === SOURCE_AUTH_OBJECT_ENTRY_FRAME) {
-    const entry: SourceAuthObjectEntry = {
-      kind: 'object',
-      groupId,
-      objectId: view.getUint32(12),
-      trueLength: view.getUint32(16),
-      digest: frame.slice(20, 52),
-    }
-    requireTrueLength(entry.trueLength)
-    return entry
-  }
-  const close: SourceAuthGroupClose = {
-    kind: 'close',
-    groupId,
-    objectCount: view.getUint32(12),
-    root: frame.slice(16, 48),
-    signature: frame.slice(48, 112),
-  }
-  if (close.objectCount === 0 || close.objectCount > SOURCE_AUTH_MAX_OBJECTS_PER_GROUP) {
-    throw new Error(`objectCount must be between 1 and ${SOURCE_AUTH_MAX_OBJECTS_PER_GROUP}`)
-  }
-  return close
-}