feat(pdf): @faunosteo/pdf engine — explicit inputs, envelope v1 attachment, layered reader, xmldom composition, allowlist SVG sanitiser, WinAnsi guard, rasterizer adapter; goldens reproduced

This commit is contained in:
bchanot committed 2026-10-11 13:09:17 +02:00
1 parent e7419cb4cb
commit c17956031d
46 files changed
+4396 -1

No files matched your search

+411
View File
@@ -0,0 +1,411 @@
/**
* T8 (STEP6 §6, §15): a hostile or oversized snapshot never sinks the
* report on import and never produces an unreadable file on export; hostile
* SVG content is removed, refused or clamped; the real assets pass the
* sanitiser untouched; the inflate bomb guard stays.
*/
import { readFileSync } from 'node:fs'
import { resolve } from 'node:path'
import { beforeAll, describe, expect, it } from 'vitest'
import {
assertSnapshot,
SnapshotError,
type Report,
type ReportArchiveEnvelope,
type SheetSnapshot,
} from '@faunosteo/domain'
import {
ArchiveExportError,
defaultPdfLabels,
exportReportArchive,
readReportArchive,
type ExportInput,
type Rasterizer,
} from '../src'
import { inflateFlate } from '../src/attachment/inflate'
import { SvgRejectedError } from '../src/errors'
import { parseSvg, serializeSvg } from '../src/svg/parse'
import { sanitizeSvgRoot } from '../src/svg/sanitize'
import { rasterSizeOf } from '../src/svg/view'
import { DRAFT_DIR, PUBLIC_DIR } from './helpers/draft'
import {
FIXED_EXPORTED_AT,
nologosBranding,
ONE_PX_PNG,
rasterizerOf,
recordDrawing,
} from './helpers/goldens'
import { pdfWithAttachment } from './helpers/pdf'
import { loadGoldenReports, type GoldenReports } from './helpers/reports'
let golden: GoldenReports
let envelope: ReportArchiveEnvelope
const clone = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T
function baseInput(report: Report, sheet: SheetSnapshot): ExportInput {
return {
report,
sheet,
branding: nologosBranding(),
labels: defaultPdfLabels,
locale: 'fr',
rasterizer: rasterizerOf('nologos'),
exportedAt: FIXED_EXPORTED_AT,
}
}
beforeAll(async () => {
golden = loadGoldenReports()
envelope = (
await exportReportArchive(
baseInput(golden.reports.demo, golden.snapshots.demo),
)
).envelope
})
/** The reason the domain gate gives: the oracle the engine must surface. */
function domainReason(snapshot: unknown): string {
try {
assertSnapshot(snapshot)
return 'accepted'
} catch (error) {
if (error instanceof SnapshotError) return error.reason
throw error
}
}
type Mutation = (snapshot: SheetSnapshot) => void
const UUID = (i: number) => `00000000-0000-4000-8000-00000000000${i}`
const MUTATIONS: Array<[string, string, Mutation]> = [
[
'5 assets',
'schema',
(s) => {
s.assets = Array.from({ length: 5 }, (_, i) => ({
...s.assets[0]!,
svgAssetId: i === 0 ? s.assets[0]!.svgAssetId : UUID(i),
}))
},
],
[
'a 3 MiB asset',
'caps',
(s) => {
s.assets[0]!.svg = 'é'.repeat(1_100_000)
},
],
[
'finding depth 9',
'caps',
(s) => {
const leaf = {
id: 'deep',
name: { fr: 'x', en: 'x' },
description: {},
requires_vet_referral: false,
reference_ids: [],
review_status: 'inherited' as const,
children: [] as never[],
}
let node: typeof leaf = leaf
for (let depth = 0; depth < 9; depth += 1) {
node = { ...leaf, id: `n${depth}`, children: [node] as never[] }
}
const zone = s.document.finding_zones.find((z) => z.categories.length)!
zone.categories[0]!.children.push(node)
},
],
[
'1,025 annotations',
'caps',
(s) => {
s.document.annotations.push(
...Array.from({ length: 1025 }, (_, i) => ({
...s.document.annotations[0]!,
id: `extra-${i}`,
})),
)
},
],
[
'a view chain cycle',
'integrity',
(s) => {
const head = s.document.views.find((v) => v.id === 'head')!
if (head.kind === 'detail') head.parent_view_id = 'head'
},
],
[
'a dangling svg_asset_id',
'integrity',
(s) => {
s.document.views.find((v) => v.kind === 'main')!.svg_asset_id = UUID(9)
},
],
[
'another sheet (sheet_mismatch)',
'sheet_mismatch',
(s) => {
s.ref.documentSha256 = 'f'.repeat(64)
},
],
]
describe('import: the report survives a rejected snapshot', () => {
it.each(MUTATIONS)(
'%s → %s',
async (_name, reason, mutate) => {
const hostile = clone(envelope)
mutate(hostile.sheetSnapshot)
if (reason !== 'sheet_mismatch') {
expect(domainReason(hostile.sheetSnapshot)).toBe(reason)
}
const bytes = await pdfWithAttachment('osteo-report.json', hostile)
const outcome = await readReportArchive(bytes, golden.draft.migrationMap)
expect(outcome.report).toEqual(golden.reports.demo)
expect(outcome.origin).toBe('envelope_v1')
expect(outcome.archive).toBeNull()
expect(outcome.snapshotRejected).toBe(reason)
},
20_000,
)
})
describe('export: a snapshot over the caps fails with a typed error and no file', () => {
it.each([
['1,025 annotations', 'snapshot_too_large', MUTATIONS[3]![2]],
['a 3 MiB asset', 'snapshot_too_large', MUTATIONS[1]![2]],
['5 assets', 'snapshot_invalid', MUTATIONS[0]![2]],
['a dangling svg_asset_id', 'snapshot_invalid', MUTATIONS[5]![2]],
['another sheet', 'sheet_mismatch', MUTATIONS[6]![2]],
] as const)('%s → %s', async (_name, kind, mutate) => {
const sheet = clone(golden.snapshots.demo)
mutate(sheet)
const promise = exportReportArchive(baseInput(golden.reports.demo, sheet))
await expect(promise).rejects.toBeInstanceOf(ArchiveExportError)
await expect(promise).rejects.toMatchObject({ kind })
})
it('too many observations or views per observation → too_many_pages', async () => {
const demo = golden.reports.demo
const many = {
...demo,
observations: Array.from({ length: 501 }, (_, i) => ({
...demo.observations[0]!,
id: `o${i}`,
})),
}
await expect(
exportReportArchive(baseInput(many, golden.snapshots.demo)),
).rejects.toMatchObject({ kind: 'too_many_pages' })
const views = {
...demo,
observations: [
{
...demo.observations[0]!,
zones: Array.from({ length: 9 }, (_, i) => ({
annotationId: 'c7-t1',
viewId: `v${i}`,
})),
},
],
}
await expect(
exportReportArchive(baseInput(views, golden.snapshots.demo)),
).rejects.toMatchObject({ kind: 'too_many_pages' })
})
})
// ---------------------------------------------------------------------------
// Hostile SVG
const SVG_OPEN =
'<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 2073.4 1629.4">'
const wrap = (inner: string) => `${SVG_OPEN}${inner}</svg>`
/** Exports the demo first observation on a snapshot whose drawing is `svg`; returns what the rasterizer saw. */
async function exportWithAsset(svg: string): Promise<string[]> {
const sheet = clone(golden.snapshots.demo)
sheet.assets[0]!.svg = svg
const seen: string[] = []
const rasterizer: Rasterizer = async (text) => {
seen.push(text)
return ONE_PX_PNG
}
const report = {
...golden.reports.demo,
observations: [golden.reports.demo.observations[0]!],
}
const { warnings } = await exportReportArchive({
...baseInput(report, sheet),
rasterizer,
})
expect(warnings).toEqual([])
return seen
}
describe('hostile SVG assets', () => {
it('<script>, on*, javascript: href, external <image>, <style> are gone from what is rasterised', async () => {
const [seen] = await exportWithAsset(
wrap(
'<script>alert(1)</script>' +
'<style>path{fill:url(http://evil.test/a)}</style>' +
'<defs><path id="p" d="M0 0h10v10z"/></defs>' +
'<path d="M0 0h1" onload="steal()" style="fill:url(http://evil.test/b)"/>' +
'<use xlink:href="javascript:alert(1)"/><use href="#p"/>' +
'<image href="https://evil.test/x.png" width="10" height="10"/>' +
'<path d="M1 1h1" fill="url(http://evil.test/c)"/>',
),
)
expect(seen).toBeDefined()
for (const forbidden of [
'<script',
'<style',
'onload',
'javascript:',
'<image',
'evil.test',
]) {
expect(seen).not.toContain(forbidden)
}
expect(seen).toContain('<use href="#p"/>')
expect(seen).toContain('<path id="p" d="M0 0h10v10z"/>')
expect(seen).toContain('fill="#b85a3f"')
})
it('the sanitiser names what it removed and clamps stdDeviation', () => {
const root = parseSvg(
wrap(
'<script>x</script><g onclick="y()" data-x="1"><path d="M0 0" style="fill:url(http://e)"/></g>' +
'<filter id="f"><feGaussianBlur stdDeviation="500,3"/><feTurbulence/></filter>' +
'<use xlink:href="javascript:z"/><a href="#ok"/>',
),
)
const { removed } = sanitizeSvgRoot(root)
expect(removed).toEqual([
'script',
'g@onclick',
'g@data-x',
'path@style',
'feTurbulence',
'use@xlink:href',
'a',
])
expect(serializeSvg(root)).toContain('stdDeviation="100 3"')
})
it('<!ENTITY> and 257 <use> are refused: the export fails as snapshot_invalid', async () => {
const entity =
'<?xml version="1.0"?><!DOCTYPE svg [<!ENTITY x "y">]>' + wrap('&x;')
await expect(exportWithAsset(entity)).rejects.toMatchObject({
kind: 'snapshot_invalid',
})
const uses = (count: number) =>
wrap(
'<defs><path id="p" d="M0 0h1"/></defs>' +
'<use href="#p"/>'.repeat(count),
)
await expect(exportWithAsset(uses(257))).rejects.toMatchObject({
kind: 'snapshot_invalid',
})
expect(() => sanitizeSvgRoot(parseSvg(uses(257)))).toThrow(SvgRejectedError)
await expect(exportWithAsset(uses(256))).resolves.toHaveLength(1)
})
it('a huge root viewBox is clamped to a 1200×2400 raster', async () => {
expect(rasterSizeOf('0 0 1 100000')).toEqual({
widthPx: 1200,
heightPx: 2400,
})
expect(rasterSizeOf('0 0 100000 1')).toEqual({
widthPx: 1200,
heightPx: 240,
})
expect(rasterSizeOf(null)).toEqual({ widthPx: 1200, heightPx: 720 })
const sizes: Array<{ widthPx: number; heightPx: number }> = []
const branding = nologosBranding()
branding.partner!.logo = {
kind: 'svg',
svg: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 100000"><rect width="1" height="1"/></svg>',
}
await exportReportArchive({
...baseInput(golden.reports.demo, golden.snapshots.demo),
branding,
rasterizer: async (_svg, size) => {
sizes.push(size)
return ONE_PX_PNG
},
})
expect(sizes[0]).toEqual({ widthPx: 1200, heightPx: 2400 })
})
it('horse.svg and Paws_in_harmony.svg pass with nothing removed and an identical serialisation', () => {
for (const file of [
resolve(DRAFT_DIR, 'assets/horse.svg'),
resolve(PUBLIC_DIR, 'Paws_in_harmony.svg'),
]) {
const text = readFileSync(file, 'utf8')
const pristine = serializeSvg(parseSvg(text))
const root = parseSvg(text)
expect(sanitizeSvgRoot(root)).toEqual({ removed: [] })
expect(serializeSvg(root)).toBe(pristine)
}
})
})
describe('__proto__ ids and the inflate bomb', () => {
it('report ids named __proto__ print raw and pollute nothing', async () => {
const demo = golden.reports.demo
const report: Report = {
...demo,
observations: [
{
...demo.observations[0]!,
zones: [{ annotationId: '__proto__', viewId: 'main' }],
findings: [
{
findingZoneId: '__proto__',
path: ['__proto__'],
labelFrSnapshot: 'proto fr',
labelEnSnapshot: 'proto en',
},
],
},
],
}
const recording = recordDrawing()
try {
const { warnings } = await exportReportArchive(
baseInput(report, golden.snapshots.demo),
)
expect(warnings).toEqual([])
const drawn = recording.texts.map((t) => t.text)
expect(drawn).toContain('__proto__')
expect(drawn).toContain('CONSTATS — __PROTO__')
expect(drawn).toContain('proto fr')
} finally {
recording.stop()
}
expect(Object.keys(Object.prototype)).toEqual([])
expect(({} as Record<string, unknown>).polluted).toBeUndefined()
})
async function deflate(data: Uint8Array): Promise<Uint8Array> {
const stream = new Blob([data])
.stream()
.pipeThrough(new CompressionStream('deflate'))
return new Uint8Array(await new Response(stream).arrayBuffer())
}
it('inflates a normal payload and returns null for a 24 MB bomb', async () => {
const payload = new TextEncoder().encode(JSON.stringify({ version: 2 }))
const out = await inflateFlate(await deflate(payload))
expect(new TextDecoder().decode(out!)).toContain('version')
const bomb = await deflate(new Uint8Array(24 * 1024 * 1024))
expect(bomb.byteLength).toBeLessThan(1024 * 1024)
expect(await inflateFlate(bomb)).toBeNull()
})
})