@blockcast/mmt-container 0.1.0-main.149f78a4adae

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

@@ -0,0 +1,171 @@
+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

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

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

@@ -0,0 +1,230 @@
+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
+}