/** * Minimal, defensive ZIP reader for OOXML packages (DOCX / PPTX). * * Reads the central directory itself and inflates entries through fflate's * streaming inflater in small input slices, so both memory and CPU are bounded * by the limits below even when the archive lies about its sizes (zip bombs). */ import { Inflate } from 'fflate'; export interface ZipEntry { name: string; method: number; compressedSize: number; size: number; offset: number; encrypted: boolean; } export interface ZipLimits { /** Largest uncompressed size accepted for a single entry. */ maxEntryBytes: number; /** Largest total of uncompressed bytes read through one reader. */ maxTotalBytes: number; } export class ZipError extends Error { code: 'corrupt' | 'too_large'; constructor(code: ZipError['code'], message: string) { super(message); this.name = 'ZipError'; this.code = code; } } const EOCD_SIG = 0x06054b50; const ZIP64_LOCATOR_SIG = 0x07064b50; const ZIP64_EOCD_SIG = 0x06064b50; const CENTRAL_SIG = 0x02014b50; const LOCAL_SIG = 0x04034b50; const MAX_ENTRIES = 20_000; const INFLATE_STEP = 64 * 1024; const nameDecoder = new TextDecoder('utf-8'); function u16(b: Uint8Array, o: number): number { return b[o] | (b[o + 1] << 8); } function u32(b: Uint8Array, o: number): number { return (b[o] | (b[o + 1] << 8) | (b[o + 2] << 16) | (b[o + 3] << 24)) >>> 0; } function u64(b: Uint8Array, o: number): number { return u32(b, o) + u32(b, o + 4) * 0x1_0000_0000; } /** Parses the central directory. Throws ZipError('corrupt') when it cannot be read. */ export function listZip(bytes: Uint8Array): ZipEntry[] { const len = bytes.length; if (len < 22) throw new ZipError('corrupt', 'Not a zip archive'); let eocd = -1; const stop = Math.max(0, len - 22 - 0xffff); for (let i = len - 22; i >= stop; i--) { if (bytes[i] === 0x50 && u32(bytes, i) === EOCD_SIG) { eocd = i; break; } } if (eocd < 0) throw new ZipError('corrupt', 'Zip directory not found'); let count = u16(bytes, eocd + 10); let dirOffset = u32(bytes, eocd + 16); if (count === 0xffff || dirOffset === 0xffffffff) { const locator = eocd - 20; if (locator < 0 || u32(bytes, locator) !== ZIP64_LOCATOR_SIG) throw new ZipError('corrupt', 'Bad zip64 locator'); const z = u64(bytes, locator + 8); if (z + 56 > len || u32(bytes, z) !== ZIP64_EOCD_SIG) throw new ZipError('corrupt', 'Bad zip64 directory'); count = u64(bytes, z + 32); dirOffset = u64(bytes, z + 48); } if (count > MAX_ENTRIES) throw new ZipError('too_large', 'Too many files in archive'); const entries: ZipEntry[] = []; let p = dirOffset; for (let i = 0; i < count; i++) { if (p + 46 > len || u32(bytes, p) !== CENTRAL_SIG) throw new ZipError('corrupt', 'Bad zip directory entry'); const flags = u16(bytes, p + 8); const method = u16(bytes, p + 10); let compressedSize = u32(bytes, p + 20); let size = u32(bytes, p + 24); const nameLen = u16(bytes, p + 28); const extraLen = u16(bytes, p + 30); const commentLen = u16(bytes, p + 32); let offset = u32(bytes, p + 42); const nameStart = p + 46; const extraStart = nameStart + nameLen; const next = extraStart + extraLen + commentLen; if (next > len) throw new ZipError('corrupt', 'Truncated zip directory'); if (size === 0xffffffff || compressedSize === 0xffffffff || offset === 0xffffffff) { // zip64 extended information: only the saturated fields are present, in this order. let e = extraStart; const extraEnd = extraStart + extraLen; while (e + 4 <= extraEnd) { const id = u16(bytes, e); const dataLen = u16(bytes, e + 2); if (id === 1) { let q = e + 4; if (size === 0xffffffff && q + 8 <= extraEnd) (size = u64(bytes, q)), (q += 8); if (compressedSize === 0xffffffff && q + 8 <= extraEnd) (compressedSize = u64(bytes, q)), (q += 8); if (offset === 0xffffffff && q + 8 <= extraEnd) offset = u64(bytes, q); break; } e += 4 + dataLen; } } const name = nameDecoder.decode(bytes.subarray(nameStart, extraStart)).replace(/\\/g, '/'); entries.push({ name, method, compressedSize, size, offset, encrypted: (flags & 1) === 1 }); p = next; } return entries; } /** Random-access reader over a zip held in memory, with per-entry and total size limits. */ export class ZipReader { private readonly bytes: Uint8Array; private readonly limits: ZipLimits; private readonly byName = new Map(); private totalRead = 0; readonly entries: ZipEntry[]; constructor(bytes: Uint8Array, limits: ZipLimits) { this.bytes = bytes; this.limits = limits; this.entries = listZip(bytes); for (const entry of this.entries) if (!this.byName.has(entry.name)) this.byName.set(entry.name, entry); } has(name: string): boolean { return this.byName.has(name); } names(): string[] { return this.entries.map((entry) => entry.name); } /** Uncompressed bytes of an entry, or null when it does not exist. */ read(name: string): Uint8Array | null { const entry = this.byName.get(name); if (!entry) return null; if (entry.encrypted) throw new ZipError('corrupt', 'Encrypted zip entry'); if (entry.size > this.limits.maxEntryBytes) throw new ZipError('too_large', `Entry too large: ${name}`); if (this.totalRead + entry.size > this.limits.maxTotalBytes) throw new ZipError('too_large', 'Archive too large'); const b = this.bytes; const o = entry.offset; if (o + 30 > b.length || u32(b, o) !== LOCAL_SIG) throw new ZipError('corrupt', 'Bad zip file header'); const dataStart = o + 30 + u16(b, o + 26) + u16(b, o + 28); const dataEnd = dataStart + entry.compressedSize; if (dataEnd > b.length) throw new ZipError('corrupt', 'Truncated zip entry'); const compressed = b.subarray(dataStart, dataEnd); let out: Uint8Array; if (entry.method === 0) { if (compressed.length !== entry.size) throw new ZipError('corrupt', 'Zip entry size mismatch'); out = compressed; } else if (entry.method === 8) { out = this.inflate(compressed, entry.size); } else { throw new ZipError('corrupt', `Unsupported zip compression method ${entry.method}`); } this.totalRead += out.length; return out; } readText(name: string): string | null { const data = this.read(name); if (!data) return null; let text = new TextDecoder('utf-8').decode(data); if (text.charCodeAt(0) === 0xfeff) text = text.slice(1); return text; } private inflate(compressed: Uint8Array, expected: number): Uint8Array { const out = new Uint8Array(expected); let written = 0; let overflow = false; const inflater = new Inflate((chunk) => { if (overflow) return; if (written + chunk.length > expected) { overflow = true; return; } out.set(chunk, written); written += chunk.length; }); try { if (compressed.length === 0) { inflater.push(compressed, true); } else { for (let p = 0; p < compressed.length && !overflow; p += INFLATE_STEP) { const end = Math.min(p + INFLATE_STEP, compressed.length); inflater.push(compressed.subarray(p, end), end === compressed.length); } } } catch { throw new ZipError('corrupt', 'Zip entry could not be decompressed'); } // More data than the directory declared is the signature of a zip bomb. if (overflow) throw new ZipError('too_large', 'Zip entry larger than declared'); if (written !== expected) throw new ZipError('corrupt', 'Zip entry size mismatch'); return out; } }