From cb95627a11a4ee57891bb980ca4b9edb96e99e49 Mon Sep 17 00:00:00 2001 From: bchanot Date: Sun, 11 Oct 2026 14:52:03 +0200 Subject: [PATCH] fix(pdf): PNG gate inflates IDAT natively against the exact raw size, validates IHDR fields, refuses zero dimensions and interlace (UPNG inflateRaw spin) --- docs/PDF-FORMAT.md | 39 +++- packages/pdf/src/attachment/inflate.ts | 9 +- packages/pdf/src/branding.ts | 149 +++++++++++-- packages/pdf/tests/security.test.ts | 291 +++++++++++++++++++++---- 4 files changed, 412 insertions(+), 76 deletions(-) diff --git a/docs/PDF-FORMAT.md b/docs/PDF-FORMAT.md index 460c16d4..9e029430 100644 --- a/docs/PDF-FORMAT.md +++ b/docs/PDF-FORMAT.md @@ -162,7 +162,7 @@ Two operations are distinct: | snapshot document | ≤ 64 views, ≤ 1,024 annotations, ≤ 8,192 finding nodes, depth ≤ 8, names ≤ 512 chars | | branding | PNG base64 ≤ 512 KiB, SVG ≤ 256 KiB, http(s) URLs ≤ 2,048 chars | | branding URL | `http(s)://` then printable ASCII only, without `"` `'` `(` `)` `<` `>` `\`, no space or control character | -| branding PNG | valid signature, one IHDR (13 bytes) first, then only `PLTE` `tRNS` `IDAT` `gAMA` `cHRM` `sRGB` `sBIT` `pHYs` `bKGD`, no chunk past the buffer, an empty `IEND` as the last bytes, each side ≤ 8,192 px, ≤ 16,777,216 px (4096²) | +| branding PNG | valid signature, one IHDR (13 bytes) first with a colour type and bit depth the spec allows, compression and filter method 0, no interlace; each side 1 to 8,192 px, ≤ 16,777,216 px (4096²), expected raw scanline size ≤ 16 MiB; then only `PLTE` `tRNS` `IDAT` `gAMA` `cHRM` `sRGB` `sBIT` `pHYs` `bKGD`, no chunk past the buffer, an empty `IEND` as the last bytes; the IDAT stream inflated natively and yielding exactly the raw scanline size | | report at export | ≤ 500 observations, ≤ 8 views per observation | | SVG sanitiser | ≤ 20,000 elements, nesting ≤ 64, ≤ 256 ``, blur `stdDeviation` ≤ 100 | @@ -188,17 +188,32 @@ receives (`ArchiveExportError('branding_invalid')` before any page is drawn), even from an archive that passed the reader. The URI itself is the hex form of the URL's ASCII bytes (`<68747470…>`), not UTF-16 with a BOM, so readers that take `/URI` as raw bytes (poppler) follow it. A PNG logo is -checked before decoding: the signature and a first 13-byte IHDR, then the -chunk list is walked and must end on an empty `IEND` that closes the file. -Only the chunk types the decoder reads by fixed offsets or by declared -length are accepted (`PLTE`, `tRNS`, `IDAT`, `IEND`, `gAMA`, `cHRM`, `sRGB`, -`sBIT`, `pHYs`, `bKGD`); a second IHDR (the decoder would size its buffer -from the last one), an APNG chunk, a text or profile chunk (`tEXt`, `iTXt`, -`zTXt`, `iCCP`: the decoder scans them for a NUL byte and never stops when -none follows in the buffer), an unknown type, a chunk length past the end -of the buffer, a missing IEND or bytes after it, or a header over the pixel -budget refuses the slot. The archive accepts only PNGs ending on IEND, even -though the decoder reads a PNG without one. That slot alone prints its +checked before pdf-lib's decoder (UPNG) sees it, because that decoder trusts +its input: it sizes its bitmap from whatever IHDR claims, its `inflateRaw` +never checks the input bound (a truncated or crafted IDAT stream makes it +read past the buffer and never return), and it scans text chunks for a NUL +byte that may be missing. The gate therefore validates, in order: the +signature and a first 13-byte IHDR; a width and height of at least 1 under +the pixel budget; a colour type and bit depth the PNG spec allows (0: 1 to +16 bits, 2 and 4 and 6: 8 or 16, 3: 1 to 8), compression and filter method +0 and no interlace (the archived logos are never interlaced, so Adam7 pass +sizes are not computed); an expected raw scanline size, +`(ceil(width × bits per pixel / 8) + 1) × height`, of at most 16 MiB, the +attachment cap the native inflater enforces, which is the effective budget +(4096² at 8-bit RGBA is 67 MB of scanlines and is refused; a 512 px wide +logo is under 1 MB); then the chunk list, which must end on an empty `IEND` +that closes the file and may hold only the chunk types the decoder reads by +fixed offsets or by declared length (`PLTE`, `tRNS`, `IDAT`, `IEND`, +`gAMA`, `cHRM`, `sRGB`, `sBIT`, `pHYs`, `bKGD`): a second IHDR, an APNG +chunk, a text or profile chunk (`tEXt`, `iTXt`, `zTXt`, `iCCP`), an unknown +type, a chunk length past the end of the buffer, a missing IEND or bytes +after it refuse the slot. Last, the IDAT payloads are concatenated and +inflated with the platform's `DecompressionStream`, bounded to the expected +raw size: a truncated, corrupt or oversized stream, or one that does not +yield exactly that size, refuses the slot. The allowlist alone would not +make the decoder safe; the native inflation is what keeps it from reading +an unbounded stream. The archive accepts only PNGs ending on IEND, even +though the decoder reads a PNG without one. A refused slot alone prints its fallback text and the export reports `logo_failed`. ### Known limits diff --git a/packages/pdf/src/attachment/inflate.ts b/packages/pdf/src/attachment/inflate.ts index 9483489a..f11af1bc 100644 --- a/packages/pdf/src/attachment/inflate.ts +++ b/packages/pdf/src/attachment/inflate.ts @@ -14,9 +14,14 @@ function concat(chunks: Uint8Array[], total: number): Uint8Array { return out } -/** FlateDecode under the cap. Null on failure or when the cap is exceeded. */ +/** + * FlateDecode (zlib framing) under `limit`, the attachment cap by default. + * Null on any failure (truncated or corrupt stream, trailing junk, bad + * checksum) or as soon as the output exceeds the limit. + */ export async function inflateFlate( bytes: Uint8Array, + limit: number = MAX_ATTACHMENT_BYTES, ): Promise { if (typeof DecompressionStream === 'undefined') return null try { @@ -31,7 +36,7 @@ export async function inflateFlate( const { done, value } = await reader.read() if (done) break total += value.byteLength - if (total > MAX_ATTACHMENT_BYTES) { + if (total > limit) { await reader.cancel() return null } diff --git a/packages/pdf/src/branding.ts b/packages/pdf/src/branding.ts index 362388fb..c112142f 100644 --- a/packages/pdf/src/branding.ts +++ b/packages/pdf/src/branding.ts @@ -1,18 +1,27 @@ import type { PDFDocument, PDFImage } from 'pdf-lib' import type { Branding, Credit, ImageAsset } from '@faunosteo/domain' +import { inflateFlate, MAX_ATTACHMENT_BYTES } from './attachment/inflate' import type { ExportWarning, Rasterizer } from './types' import { renderBrandingSvg } from './svg/view' /** * The branding images embedded once per document. A PNG is decoded from - * its base64 once its header and chunk list fit the pixel budget; an SVG is - * sanitised and rasterised at the view width. Each slot fails alone: the - * page prints the credit's fallback text instead and the export reports a - * `logo_failed` warning. + * its base64 once its header, chunk list and IDAT stream pass `pngIssue`; + * an SVG is sanitised and rasterised at the view width. Each slot fails + * alone: the page prints the credit's fallback text instead and the export + * reports a `logo_failed` warning. */ -/** A logo PNG is at most 4096² pixels and 8192 px a side (STEP6 §15). */ -export const PNG_CAPS = { side: 8192, pixels: 4096 * 4096 } as const +/** + * A logo PNG is at most 4096² pixels and 8192 px a side (STEP6 §15), and + * its raw (filtered, uncompressed) scanlines fit the attachment cap, the + * most the native inflater is allowed to produce. + */ +export const PNG_CAPS = { + side: 8192, + pixels: 4096 * 4096, + rawBytes: MAX_ATTACHMENT_BYTES, +} as const const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] /** A chunk is length (4), type (4), data (length), CRC (4). */ @@ -26,6 +35,7 @@ const chunkType = (name: string): number => [...name].reduce((acc, char) => acc * 256 + char.charCodeAt(0), 0) const IHDR_TYPE = chunkType('IHDR') +const IDAT_TYPE = chunkType('IDAT') const IEND_TYPE = chunkType('IEND') /** * The chunk types UPNG reads by fixed offsets or by declared length. A @@ -49,7 +59,28 @@ const ALLOWED_CHUNKS = new Set( ].map(chunkType), ) -export type PngHeaderIssue = 'signature' | 'dimensions' | 'chunks' +/** Samples per pixel and the bit depths the PNG spec allows, by colour type. */ +const CHANNELS: Record = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 } +const DEPTHS: Record = { + 0: [1, 2, 4, 8, 16], + 2: [8, 16], + 3: [1, 2, 4, 8], + 4: [8, 16], + 6: [8, 16], +} + +export type PngIssue = 'signature' | 'dimensions' | 'ihdr' | 'chunks' | 'idat' + +/** The 13 IHDR fields, read as announced. */ +interface PngHeader { + width: number + height: number + depth: number + colourType: number + compression: number + filter: number + interlace: number +} export type LogoSlot = Extract['slot'] @@ -68,25 +99,66 @@ export interface BrandingImages { } /** - * Why a PNG is refused before any decoding, or null when it fits the - * budget: the signature and a first IHDR chunk of 13 bytes must be there, - * the announced width × height must stay under `PNG_CAPS`, and the chunk - * list must hold only allowlisted types, none past the end of the buffer, - * closed by an `IEND` that ends the file. The decoder would otherwise - * allocate the bitmap of whatever size the last IHDR claims, or scan past - * the buffer for a NUL byte that is not there. + * Why a PNG is refused before UPNG sees it, or null when it may be decoded. + * In order: the signature and a first 13-byte IHDR (`signature`); the + * announced size under `PNG_CAPS` (`dimensions`); IHDR fields the spec + * allows, non-interlaced (`ihdr`); an allowlisted chunk list closed by an + * empty `IEND` (`chunks`); an IDAT stream the native inflater accepts and + * that yields exactly the raw scanline size (`idat`). UPNG's `inflateRaw` + * never checks its input bound, so a truncated or crafted stream makes it + * read past the buffer and never return; its bitmap is sized from whatever + * IHDR claims; and `nextZero` scans text chunks for a NUL that may be + * missing. Each check closes one of those paths. */ -export function pngHeaderIssue(bytes: Uint8Array): PngHeaderIssue | null { +export async function pngIssue(bytes: Uint8Array): Promise { if (bytes.byteLength < IHDR_END) return 'signature' if (PNG_SIGNATURE.some((byte, i) => bytes[i] !== byte)) return 'signature' const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength) if (view.getUint32(8) !== IHDR_LENGTH) return 'signature' if (view.getUint32(12) !== IHDR_TYPE) return 'signature' - const width = view.getUint32(16) - const height = view.getUint32(20) + const header = readHeader(view) + const headerProblem = headerIssue(header) + if (headerProblem) return headerProblem + const rawSize = expectedRawSize(header) + if (rawSize > PNG_CAPS.rawBytes) return 'dimensions' + return chunkListIssue(view) ?? idatIssue(view, rawSize) +} + +function readHeader(view: DataView): PngHeader { + return { + width: view.getUint32(16), + height: view.getUint32(20), + depth: view.getUint8(24), + colourType: view.getUint8(25), + compression: view.getUint8(26), + filter: view.getUint8(27), + interlace: view.getUint8(28), + } +} + +/** + * The size budget, then the IHDR fields: a side of 0 would give the page + * stream an Infinity scale, an unknown colour type or depth (255 at 4096² + * costs seconds of CPU in UPNG) has no raw size to check against, and an + * interlaced image is refused outright: no archived logo is interlaced and + * the Adam7 pass sizes are not worth computing here. + */ +function headerIssue(header: PngHeader): PngIssue | null { + const { width, height, depth, colourType } = header + if (width < 1 || height < 1) return 'dimensions' if (width > PNG_CAPS.side || height > PNG_CAPS.side) return 'dimensions' if (width * height > PNG_CAPS.pixels) return 'dimensions' - return chunkListIssue(view) + if (!DEPTHS[colourType]?.includes(depth)) return 'ihdr' + if (header.compression !== 0 || header.filter !== 0) return 'ihdr' + if (header.interlace !== 0) return 'ihdr' + return null +} + +/** Non-interlaced raw size: each scanline is a filter byte plus its packed samples. */ +function expectedRawSize(header: PngHeader): number { + const bitsPerPixel = CHANNELS[header.colourType]! * header.depth + const rowBytes = Math.ceil((header.width * bitsPerPixel) / 8) + 1 + return rowBytes * header.height } /** @@ -96,7 +168,7 @@ export function pngHeaderIssue(bytes: Uint8Array): PngHeaderIssue | null { * `nextZero` forever, an unknown type), a declared length past the buffer, * a truncated chunk head, a missing IEND or bytes after it are refused. */ -function chunkListIssue(view: DataView): PngHeaderIssue | null { +function chunkListIssue(view: DataView): PngIssue | null { let offset = IHDR_END while (offset + CHUNK_HEAD <= view.byteLength) { const length = view.getUint32(offset) @@ -112,6 +184,43 @@ function chunkListIssue(view: DataView): PngHeaderIssue | null { return 'chunks' } +/** The IDAT payloads in file order, one zlib stream; the chunk list is already known sound. */ +function idatPayload(view: DataView): Uint8Array { + const parts: Uint8Array[] = [] + let total = 0 + let offset = IHDR_END + while (offset + CHUNK_HEAD <= view.byteLength) { + const length = view.getUint32(offset) + if (view.getUint32(offset + 4) === IDAT_TYPE) { + const start = view.byteOffset + offset + CHUNK_HEAD + parts.push(new Uint8Array(view.buffer, start, length)) + total += length + } + offset += CHUNK_OVERHEAD + length + } + const payload = new Uint8Array(total) + let at = 0 + for (const part of parts) { + payload.set(part, at) + at += part.byteLength + } + return payload +} + +/** + * Inflates the IDAT stream with the native, bounded inflater before UPNG's + * unbounded `inflateRaw` does: a truncated, corrupt or oversized stream, or + * one that does not yield exactly the raw scanline size, is refused. + */ +async function idatIssue( + view: DataView, + rawSize: number, +): Promise { + const raw = await inflateFlate(idatPayload(view), rawSize) + if (!raw || raw.byteLength !== rawSize) return 'idat' + return null +} + function base64ToBytes(base64: string): Uint8Array { const binary = atob(base64) const bytes = new Uint8Array(binary.length) @@ -126,7 +235,7 @@ async function embedImage( ): Promise { if (asset.kind === 'png') { const bytes = base64ToBytes(asset.base64) - const issue = pngHeaderIssue(bytes) + const issue = await pngIssue(bytes) if (issue) throw new Error(`png refused: ${issue}`) return pdfDoc.embedPng(bytes) } diff --git a/packages/pdf/tests/security.test.ts b/packages/pdf/tests/security.test.ts index 5fd599e0..cf88be88 100644 --- a/packages/pdf/tests/security.test.ts +++ b/packages/pdf/tests/security.test.ts @@ -6,6 +6,7 @@ */ import { readFileSync } from 'node:fs' import { resolve } from 'node:path' +import { deflateSync } from 'node:zlib' import { beforeAll, describe, expect, it, vi } from 'vitest' import { PDFDict, PDFDocument, PDFName } from 'pdf-lib' import { @@ -26,7 +27,7 @@ import { type Rasterizer, } from '../src' import { inflateFlate } from '../src/attachment/inflate' -import { pngHeaderIssue } from '../src/branding' +import { pngIssue } from '../src/branding' import { SvgRejectedError } from '../src/errors' import { addLinkAnnotation } from '../src/render/linkAnnotation' import { parseSvg, serializeSvg } from '../src/svg/parse' @@ -579,20 +580,37 @@ describe('branding URL injection (HIGH)', () => { }) }) -/** A PNG signature and an IHDR chunk announcing `width` × `height`, nothing after. */ +interface IhdrFields { + depth?: number + colourType?: number + compression?: number + filter?: number + interlace?: number +} + +const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a] + +/** + * A PNG signature and an IHDR chunk announcing `width` × `height`, 8-bit + * greyscale non-interlaced unless `fields` says otherwise, nothing after. + */ function pngHeader( width: number, height: number, + fields: IhdrFields = {}, signature = true, ): Uint8Array { const bytes = new Uint8Array(33) - bytes.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]) + bytes.set(PNG_SIGNATURE) if (!signature) bytes[3] = 0x48 const view = new DataView(bytes.buffer) view.setUint32(8, 13) bytes.set([0x49, 0x48, 0x44, 0x52], 12) view.setUint32(16, width) view.setUint32(20, height) + const { depth = 8, colourType = 0, compression = 0 } = fields + const { filter = 0, interlace = 0 } = fields + bytes.set([depth, colourType, compression, filter, interlace], 24) return bytes } @@ -611,8 +629,36 @@ function pngChunk(type: string, data: Uint8Array): Uint8Array { const concat = (...parts: Uint8Array[]): Uint8Array => Uint8Array.from(Buffer.concat(parts.map((p) => Buffer.from(p)))) +const CHANNELS: Record = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 } + +/** Raw scanlines of a non-interlaced image: a filter byte then the packed samples, per row. */ +function rawSize( + width: number, + height: number, + fields: IhdrFields = {}, +): number { + const { depth = 8, colourType = 0 } = fields + const bitsPerPixel = CHANNELS[colourType]! * depth + return (Math.ceil((width * bitsPerPixel) / 8) + 1) * height +} + +/** An IDAT chunk holding the zlib stream of `raw`. */ +const idatOf = (raw: Uint8Array): Uint8Array => + pngChunk('IDAT', deflateSync(raw)) + const IEND = pngChunk('IEND', new Uint8Array(0)) -const IDAT = pngChunk('IDAT', new Uint8Array(16)) +/** The IDAT of a 1×1 8-bit greyscale image (2 raw bytes), what `pngHeader(1, 1)` announces. */ +const IDAT = idatOf(new Uint8Array(2)) + +/** A complete valid PNG of zero pixels: header, one IDAT of the exact raw size, IEND. */ +function validPng( + width: number, + height: number, + fields: IhdrFields = {}, +): Uint8Array { + const raw = new Uint8Array(rawSize(width, height, fields)) + return concat(pngHeader(width, height, fields), idatOf(raw), IEND) +} /** A 1×1 header followed by a second IHDR announcing 10000 × 10000, then IEND. */ function doubledIhdrPng(): Uint8Array { @@ -638,24 +684,158 @@ function itxtThenFatIendPng(): Uint8Array { return concat(pngHeader(1, 1), IDAT, itxt, fatIend) } +/** + * The third PoC, 77 bytes: 16×16 RGBA, a zlib IDAT cut to 20 bytes, IEND. + * Signature and chunk list are sound; UPNG's `inflateRaw` reads past the + * end of the stream and never returns. + */ +function truncatedIdatPng(): Uint8Array { + const raw = Uint8Array.from( + { length: rawSize(16, 16, { colourType: 6 }) }, + (_, i) => i & 0xff, + ) + const stream = deflateSync(raw).subarray(0, 20) + const header = pngHeader(16, 16, { colourType: 6 }) + return concat(header, pngChunk('IDAT', stream), IEND) +} + +interface Chunk { + type: string + data: Uint8Array +} + +/** The chunks of a well-formed PNG, in file order, CRCs dropped. */ +function chunksOf(png: Uint8Array): Chunk[] { + const view = new DataView(png.buffer, png.byteOffset, png.byteLength) + const chunks: Chunk[] = [] + let offset = 8 + while (offset < png.byteLength) { + const length = view.getUint32(offset) + const type = String.fromCharCode(...png.subarray(offset + 4, offset + 8)) + chunks.push({ type, data: png.subarray(offset + 8, offset + 8 + length) }) + offset += 12 + length + } + return chunks +} + +const pngOf = (chunks: Chunk[]): Uint8Array => + concat( + Uint8Array.from(PNG_SIGNATURE), + ...chunks.map((c) => pngChunk(c.type, c.data)), + ) + +function headerLogoBytes(): Uint8Array { + const asset = logosBranding().headerLogo + if (asset?.kind !== 'png') throw new Error('png expected') + return Uint8Array.from(Buffer.from(asset.base64, 'base64')) +} + +/** The real header logo with the last 5 bytes of its IDAT stream removed: the chunk list stays sound. */ +function cutLogoPng(): Uint8Array { + const chunks = chunksOf(headerLogoBytes()) + const last = chunks.filter((c) => c.type === 'IDAT').at(-1)! + last.data = last.data.subarray(0, last.data.byteLength - 5) + return pngOf(chunks) +} + describe('PNG budget (MEDIUM)', () => { it.each([ - ['8193 × 1 → dimensions', 8193, 1, 'dimensions'], - ['1 × 8193 → dimensions', 1, 8193, 'dimensions'], - ['4097 × 4096 (over 4096²) → dimensions', 4097, 4096, 'dimensions'], - ['12000 × 12000 (144 Mpx) → dimensions', 12_000, 12_000, 'dimensions'], - ['4096 × 4096 → accepted', 4096, 4096, null], - ['8192 × 2048 → accepted', 8192, 2048, null], - ])('%s', (_name, width, height, issue) => { - expect(pngHeaderIssue(concat(pngHeader(width, height), IEND))).toBe(issue) + ['8193 × 1', 8193, 1], + ['1 × 8193', 1, 8193], + ['4097 × 4096 (over 4096²)', 4097, 4096], + ['12000 × 12000 (144 Mpx)', 12_000, 12_000], + ['0 × 0', 0, 0], + ['1 × 0', 1, 0], + ['8192 × 0', 8192, 0], + ])('%s → dimensions', async (_name, width, height) => { + const png = concat(pngHeader(width, height), IEND) + expect(await pngIssue(png)).toBe('dimensions') }) - it('a wrong signature or a truncated header is refused; the real logos pass', () => { - expect(pngHeaderIssue(pngHeader(1, 1, false))).toBe('signature') - expect(pngHeaderIssue(pngHeader(1, 1).subarray(0, 20))).toBe('signature') - expect(pngHeaderIssue(new TextEncoder().encode(''))).toBe('signature') - expect(pngHeaderIssue(ONE_PX_PNG)).toBeNull() - expect(pngHeaderIssue(TWO_BY_ONE_PNG)).toBeNull() + it('the raw-size budget: 16 MiB of scanlines at most, whatever the pixel count', async () => { + // 1-bit grey: 513 bytes a row. + expect(await pngIssue(validPng(4096, 4096, { depth: 1 }))).toBeNull() + expect(await pngIssue(validPng(8192, 2048, { depth: 1 }))).toBeNull() + // 8-bit grey: (4095 + 1) × 4096 is exactly 16 MiB, one more row byte is over. + expect(await pngIssue(validPng(4095, 4096))).toBeNull() + const overByARow = concat(pngHeader(4096, 4096), IEND) + expect(await pngIssue(overByARow)).toBe('dimensions') + // 8-bit RGBA at 4096²: 67 MB of scanlines, refused before any inflation. + const rgba = concat(pngHeader(4096, 4096, { colourType: 6 }), IEND) + expect(await pngIssue(rgba)).toBe('dimensions') + expect(rawSize(4096, 4096, { colourType: 6 })).toBeGreaterThan( + 16 * 1024 * 1024, + ) + }) + + it.each([ + ['depth 255', { depth: 255 }], + ['colour type 5', { colourType: 5 }], + ['interlace 1 (Adam7)', { interlace: 1 }], + ['filter method 1', { filter: 1 }], + ['compression method 1', { compression: 1 }], + ['depth 4 for RGBA', { depth: 4, colourType: 6 }], + ['depth 16 for a palette', { depth: 16, colourType: 3 }], + ])('%s → ihdr', async (_name, fields: IhdrFields) => { + expect(await pngIssue(validPng(4, 3, fields))).toBe('ihdr') + const atTheCap = concat(pngHeader(4096, 4096, fields), IEND) + expect(await pngIssue(atTheCap)).toBe('ihdr') + }) + + it('every colour type and depth the spec allows passes with a matching IDAT', async () => { + const allowed: Array<[number, number[]]> = [ + [0, [1, 2, 4, 8, 16]], + [2, [8, 16]], + [3, [1, 2, 4, 8]], + [4, [8, 16]], + [6, [8, 16]], + ] + for (const [colourType, depths] of allowed) { + for (const depth of depths) { + const png = validPng(5, 3, { depth, colourType }) + expect( + await pngIssue(png), + `type ${colourType} depth ${depth}`, + ).toBeNull() + } + } + }) + + it('an IDAT stream that is truncated, empty, not zlib or off by one raw byte → idat', async () => { + const poc = truncatedIdatPng() + expect(poc.byteLength).toBe(77) + expect(await pngIssue(poc)).toBe('idat') + expect(await pngIssue(cutLogoPng())).toBe('idat') + expect(await pngIssue(concat(pngHeader(1, 1), IEND))).toBe('idat') + const notZlib = pngChunk('IDAT', new Uint8Array(16)) + expect(await pngIssue(concat(pngHeader(1, 1), notZlib, IEND))).toBe('idat') + for (const delta of [1, -1]) { + const raw = new Uint8Array(rawSize(4, 3) + delta) + const png = concat(pngHeader(4, 3), idatOf(raw), IEND) + expect(await pngIssue(png), `off by ${delta}`).toBe('idat') + } + expect(await pngIssue(validPng(4, 3))).toBeNull() + }) + + it('the IDAT stream may span several chunks', async () => { + const stream = deflateSync(new Uint8Array(rawSize(4, 3))) + const split = Math.floor(stream.byteLength / 2) + const png = concat( + pngHeader(4, 3), + pngChunk('IDAT', stream.subarray(0, split)), + pngChunk('IDAT', stream.subarray(split)), + IEND, + ) + expect(await pngIssue(png)).toBeNull() + }) + + it('a wrong signature or a truncated header is refused; the real logos pass', async () => { + expect(await pngIssue(pngHeader(1, 1, {}, false))).toBe('signature') + expect(await pngIssue(pngHeader(1, 1).subarray(0, 20))).toBe('signature') + const svg = new TextEncoder().encode('') + expect(await pngIssue(svg)).toBe('signature') + expect(await pngIssue(ONE_PX_PNG)).toBeNull() + expect(await pngIssue(TWO_BY_ONE_PNG)).toBeNull() const logos = logosBranding() for (const asset of [ logos.headerLogo, @@ -663,42 +843,42 @@ describe('PNG budget (MEDIUM)', () => { logos.poweredBy!.logo, ]) { if (asset?.kind !== 'png') throw new Error('png expected') - expect(pngHeaderIssue(Buffer.from(asset.base64, 'base64'))).toBeNull() + expect(await pngIssue(Buffer.from(asset.base64, 'base64'))).toBeNull() } const touchIcon = readFileSync(resolve(PUBLIC_DIR, 'apple-touch-icon.png')) - expect(pngHeaderIssue(new Uint8Array(touchIcon))).toBeNull() + expect(await pngIssue(new Uint8Array(touchIcon))).toBeNull() }) - it('the chunk walk refuses a second IHDR, an APNG acTL and a length past the buffer', () => { - expect(pngHeaderIssue(doubledIhdrPng())).toBe('chunks') + it('the chunk walk refuses a second IHDR, an APNG acTL and a length past the buffer', async () => { + expect(await pngIssue(doubledIhdrPng())).toBe('chunks') const apng = concat( pngHeader(1, 1), pngChunk('acTL', new Uint8Array(8)), IEND, ) - expect(pngHeaderIssue(apng)).toBe('chunks') + expect(await pngIssue(apng)).toBe('chunks') for (const type of ['fcTL', 'fdAT']) { const frame = concat( pngHeader(1, 1), pngChunk(type, new Uint8Array(4)), IEND, ) - expect(pngHeaderIssue(frame), type).toBe('chunks') + expect(await pngIssue(frame), type).toBe('chunks') } const idat = pngChunk('IDAT', new Uint8Array(16)) new DataView(idat.buffer).setUint32(0, 1_000_000) - expect(pngHeaderIssue(concat(pngHeader(1, 1), idat))).toBe('chunks') + expect(await pngIssue(concat(pngHeader(1, 1), idat))).toBe('chunks') const partialHead = concat(pngHeader(1, 1), new Uint8Array(5)) - expect(pngHeaderIssue(partialHead)).toBe('chunks') - expect(pngHeaderIssue(concat(pngHeader(1, 1), IDAT, IEND))).toBeNull() + expect(await pngIssue(partialHead)).toBe('chunks') + expect(await pngIssue(concat(pngHeader(1, 1), IDAT, IEND))).toBeNull() const shortIhdr = pngHeader(1, 1) new DataView(shortIhdr.buffer).setUint32(8, 12) - expect(pngHeaderIssue(shortIhdr)).toBe('signature') + expect(await pngIssue(shortIhdr)).toBe('signature') }) - it('a chunk UPNG reads with nextZero, or any type outside the allowlist, is refused', () => { - expect(pngHeaderIssue(textWithoutNulPng())).toBe('chunks') - expect(pngHeaderIssue(itxtThenFatIendPng())).toBe('chunks') + it('a chunk UPNG reads with nextZero, or any type outside the allowlist, is refused', async () => { + expect(await pngIssue(textWithoutNulPng())).toBe('chunks') + expect(await pngIssue(itxtThenFatIendPng())).toBe('chunks') for (const type of ['tIME', 'zTXt', 'iCCP', 'abCD']) { const png = concat( pngHeader(1, 1), @@ -706,19 +886,18 @@ describe('PNG budget (MEDIUM)', () => { pngChunk(type, new Uint8Array(7)), IEND, ) - expect(pngHeaderIssue(png), type).toBe('chunks') + expect(await pngIssue(png), type).toBe('chunks') } }) - it('the list must end on an empty IEND that closes the buffer; ancillary chunks pass', () => { + it('the list must end on an empty IEND that closes the buffer; ancillary chunks pass', async () => { const valid = concat(pngHeader(1, 1), IDAT, IEND) - expect(pngHeaderIssue(concat(valid, new Uint8Array([0])))).toBe('chunks') - expect(pngHeaderIssue(concat(pngHeader(1, 1), IDAT))).toBe('chunks') - expect( - pngHeaderIssue( - concat(pngHeader(1, 1), IDAT, pngChunk('IEND', new Uint8Array(1))), - ), - ).toBe('chunks') + expect(await pngIssue(concat(valid, new Uint8Array([0])))).toBe('chunks') + expect(await pngIssue(concat(pngHeader(1, 1), IDAT))).toBe('chunks') + const fatIend = pngChunk('IEND', new Uint8Array(1)) + expect(await pngIssue(concat(pngHeader(1, 1), IDAT, fatIend))).toBe( + 'chunks', + ) const ancillary = concat( pngHeader(1, 1), pngChunk('gAMA', new Uint8Array(4)), @@ -727,13 +906,18 @@ describe('PNG budget (MEDIUM)', () => { IDAT, IEND, ) - expect(pngHeaderIssue(ancillary)).toBeNull() + expect(await pngIssue(ancillary)).toBeNull() }) it.each([ ['an oversized header logo', () => concat(pngHeader(16_384, 16_384), IEND)], ['a doubled-IHDR header logo', doubledIhdrPng], ['a tEXt-without-NUL header logo (UPNG would spin)', textWithoutNulPng], + [ + 'a truncated-IDAT header logo (UPNG inflateRaw would read past the buffer)', + truncatedIdatPng, + ], + ['a 1 × 0 header logo', () => concat(pngHeader(1, 0), IDAT, IEND)], ])( '%s fails alone with logo_failed and never reaches embedPng', async (_name, make) => { @@ -749,7 +933,8 @@ describe('PNG budget (MEDIUM)', () => { } // The spy refuses the hostile bytes itself: a regression that lets // them through fails on the assertion below instead of spinning the - // worker in UPNG's nextZero, which no vitest timeout can interrupt. + // worker in UPNG's nextZero or inflateRaw, which no vitest timeout + // can interrupt. const realEmbedPng = PDFDocument.prototype.embedPng const embedPng = vi .spyOn(PDFDocument.prototype, 'embedPng') @@ -777,4 +962,26 @@ describe('PNG budget (MEDIUM)', () => { }, 10_000, ) + + it('the real logos reach embedPng when the gate passes them', async () => { + const embedPng = vi.spyOn(PDFDocument.prototype, 'embedPng') + try { + const { warnings } = await exportReportArchive({ + ...baseInput(golden.reports.demo, golden.snapshots.demo), + branding: logosBranding(), + rasterizer: rasterizerOf('logos'), + }) + expect(warnings).toEqual([]) + const embedded = embedPng.mock.calls.map(([png]) => + Buffer.from(png as Uint8Array).toString('base64'), + ) + const logos = logosBranding() + for (const asset of [logos.headerLogo, logos.footerLogo]) { + if (asset?.kind !== 'png') throw new Error('png expected') + expect(embedded).toContain(asset.base64) + } + } finally { + embedPng.mockRestore() + } + }) })