@patrickdk77/office-defuse 0.1.1 → 0.2.0

package/dist/rewrite-zip.js

@@ -0,0 +1,498 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePackage = writePackage;
+const stream = __importStar(require("node:stream"));
+const zlib = __importStar(require("node:zlib"));
+const crc32_1 = require("./crc32");
+const errors_1 = require("./errors");
+const io_1 = require("./io");
+const links_1 = require("./links");
+const odf_1 = require("./odf");
+const ooxml_1 = require("./ooxml");
+const rewrite_xml_1 = require("./rewrite-xml");
+const xml_1 = require("./xml");
+const zip_1 = require("./zip");
+const zip_writer_1 = require("./zip-writer");
+const VML_OFFICE_NS = 'urn:schemas-microsoft-com:office:office';
+const MACRO_RELATIONSHIPS = new Set(['http://schemas.microsoft.com/office/2006/relationships/xlmacrosheet', 'http://schemas.microsoft.com/office/2006/relationships/xlintlmacrosheet']);
+/**
+ * SpreadsheetML elements whose schema wants at least one child, which go once their last child went. An external
+ * link part whose link went goes whole.
+ */
+const LISTS = new Set(['oleObjects', 'controls', 'hyperlinks', 'externalReferences', 'externalLink']);
+async function* bytesOf(b) {
+    yield b;
+}
+const nothing = async () => undefined;
+/** Deflates what `chunks` yields. The compressed bytes wait in a spill sink for their size and CRC. */
+async function deflatedEntry(run, e, chunks) {
+    let crc = 0;
+    let size = 0;
+    const counted = (async function* () {
+        for await (const c of chunks) {
+            (0, errors_1.checkTime)(run.deadline);
+            crc = (0, crc32_1.crc32)(c, crc);
+            size += c.length;
+            yield c;
+        }
+    })();
+    const deflated = new io_1.SpillSink(run.temp, run.threshold);
+    try {
+        const src = stream.Readable.from(counted);
+        const deflater = zlib.createDeflateRaw();
+        src.on('error', err => deflater.destroy(err));
+        src.pipe(deflater);
+        for await (const c of deflater)
+            await deflated.write(c);
+        await deflated.close();
+    }
+    catch (err) {
+        await deflated.dispose();
+        throw err;
+    }
+    const info = { name: e.name, crc, size, dosTime: e.dosTime, dosDate: e.dosDate };
+    if (size === 0) {
+        await deflated.dispose();
+        return { info: { ...info, method: 0, compressedSize: 0 }, data: () => bytesOf(new Uint8Array(0)), dispose: nothing };
+    }
+    return { info: { ...info, method: 8, compressedSize: deflated.length }, data: () => deflated.read(), dispose: () => deflated.dispose() };
+}
+/** An entry whose compressed bytes are copied as they are. The run inflated them once and checked them against their CRC. */
+function copiedEntry(run, zip, e) {
+    return {
+        info: { name: e.name, method: e.method, crc: e.crc, compressedSize: e.compressedSize, size: e.size, dosTime: e.dosTime, dosDate: e.dosDate },
+        data: () => zip.raw(e),
+        dispose: nothing,
+        again: () => deflatedEntry(run, e, zip.read(e)),
+    };
+}
+/** An entry made from bytes in memory, deflated, with the time ZipWriter gives new entries. */
+function bytesEntry(name, data) {
+    const body = zlib.deflateRawSync(data);
+    return { info: { name, method: 8, crc: (0, crc32_1.crc32)(data), compressedSize: body.length, size: data.length }, data: () => bytesOf(body), dispose: nothing };
+}
+/** PDF readers take a header that starts in the first 1024 bytes of a file. */
+const PDF_WINDOW = 1024;
+const PDF_HEADER = Buffer.from('%PDF-', 'latin1');
+/** The bytes a header that starts in the window reaches. */
+const PDF_SPAN = PDF_WINDOW + PDF_HEADER.length - 1;
+/** The most entries that wait, so a package of many such entries cannot keep them all. */
+const MAX_WAITING = 16;
+/**
+ * Writes entries so that no PDF header starts in the first 1024 bytes of the archive. Entries that go, and entries
+ * rewritten to another size, move what follows, so a stored PDF, a name or a local header from deep in the upload
+ * can land where PDF readers look. A copied entry that would put a PDF header there is deflated again. Any other
+ * entry that would waits until later entries have filled the window, up to 16 of them. What still lands there fails
+ * the output check, which rejects the file.
+ */
+class PdfWindow {
+    writer;
+    head = Buffer.alloc(0);
+    waiting = [];
+    constructor(sink) {
+        this.writer = new zip_writer_1.ZipWriter({
+            write: async (b) => {
+                if (this.head.length < PDF_SPAN)
+                    this.head = Buffer.concat([this.head, b.subarray(0, PDF_SPAN - this.head.length)]);
+                await sink.write(b);
+            },
+            close: () => sink.close(),
+        });
+    }
+    /** True when writing `r` next keeps a PDF header out of the window. */
+    async clear(r) {
+        if (this.head.length >= PDF_SPAN)
+            return true;
+        const parts = [this.head, Buffer.from(this.writer.localHeader(r.info))];
+        let got = parts[0].length + parts[1].length;
+        if (got < PDF_SPAN) {
+            for await (const c of r.data()) {
+                parts.push(Buffer.from(c));
+                got += c.length;
+                if (got >= PDF_SPAN)
+                    break;
+            }
+        }
+        return !Buffer.concat(parts).subarray(0, PDF_SPAN).includes(PDF_HEADER);
+    }
+    async write(r) {
+        try {
+            await this.writer.copy(r.info, r.data());
+        }
+        finally {
+            await r.dispose();
+        }
+    }
+    async add(r) {
+        let ready = r;
+        if (!(await this.clear(ready)) && ready.again) {
+            const other = await ready.again();
+            await ready.dispose();
+            ready = other;
+        }
+        if (this.waiting.length < MAX_WAITING && !(await this.clear(ready))) {
+            this.waiting.push(ready);
+            return;
+        }
+        await this.write(ready);
+        while (this.waiting.length && this.head.length >= PDF_SPAN)
+            await this.write(this.waiting.shift());
+    }
+    /** Writes the entries still waiting, each time the first that keeps the window clear, or the first when none does. */
+    async end() {
+        while (this.waiting.length) {
+            let i = 0;
+            while (i < this.waiting.length && !(await this.clear(this.waiting[i])))
+                i++;
+            const [r] = this.waiting.splice(i < this.waiting.length ? i : 0, 1);
+            await this.write(r);
+        }
+    }
+    /** Frees what the waiting entries hold, after a failure. */
+    async dispose() {
+        for (const r of this.waiting.splice(0))
+            await r.dispose();
+    }
+}
+/** The parts the relationships reach from the package, past parts that go and out of no macro sheet that is emptied. */
+function reach(graph, drops, emptied) {
+    const key = (p) => (0, zip_1.nameKey)(p.entry.name);
+    const reached = new Set();
+    const queue = [];
+    for (const r of graph.roots) {
+        if (drops.has(key(r)) || reached.has(r))
+            continue;
+        reached.add(r);
+        queue.push(r);
+    }
+    for (let p = queue.pop(); p; p = queue.pop()) {
+        if (emptied.has(key(p)))
+            continue;
+        for (const t of p.targets) {
+            if (drops.has(key(t)) || reached.has(t))
+                continue;
+            reached.add(t);
+            queue.push(t);
+        }
+    }
+    return reached;
+}
+const escapeAttribute = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;');
+/**
+ * Writes an OOXML package without what the plan removes. A part goes with its own relationships, every relationship
+ * that targets it, its content type override, every element that names one of those relationships, and the parts
+ * only it reached. A macro sheet becomes an empty worksheet. Parts nothing changes keep their compressed bytes.
+ */
+async function writeOoxml(run, zip, plan, graph, format, limits, sink) {
+    const drops = new Set(plan.drop);
+    const sheets = plan.sheets;
+    const before = reach(graph, new Set(), new Set());
+    const relsEdits = new Map();
+    const partEditsByName = new Map();
+    const strict = graph.strict;
+    const worksheetRelationship = strict ? 'http://purl.oclc.org/ooxml/officeDocument/relationships/worksheet' : 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet';
+    const binarySheet = (k) => !(0, ooxml_1.isXmlType)(graph.parts.get(k)?.contentType) && format.format === 'xlsb';
+    const sheetType = (k) => (binarySheet(k) ? 'application/vnd.ms-excel.worksheet' : 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml');
+    // Removing an element can empty a part of its root, and that part then goes too, so this runs until nothing more goes.
+    for (;;) {
+        const after = reach(graph, drops, sheets);
+        for (const p of before)
+            if (!after.has(p))
+                drops.add((0, zip_1.nameKey)(p.entry.name));
+        for (const [source, rels] of graph.relsOf)
+            if (source !== '' && (drops.has(source) || sheets.has(source)))
+                drops.add((0, zip_1.nameKey)(rels.name));
+        const removedIds = new Map();
+        relsEdits.clear();
+        for (const [source, rels] of graph.relsOf) {
+            if (drops.has((0, zip_1.nameKey)(rels.name)))
+                continue;
+            const ids = plan.rels.get(rels.name) ?? new Set();
+            const removed = new Set();
+            const rules = {
+                element(el) {
+                    if (el.depth !== 2 || el.local !== 'Relationship' || el.ns.toLowerCase() !== ooxml_1.RELS_NS)
+                        return undefined;
+                    const id = (0, xml_1.attr)(el, '', 'Id') ?? '';
+                    const target = (0, xml_1.attr)(el, '', 'Target');
+                    if (ids.has(id)) {
+                        removed.add(id);
+                        return { remove: true };
+                    }
+                    if (target === undefined)
+                        return undefined;
+                    const external = ((0, xml_1.attr)(el, '', 'TargetMode') ?? 'Internal').trim().toLowerCase() !== 'internal' || (0, links_1.isAbsoluteTarget)(target);
+                    if (external)
+                        return undefined;
+                    const k = (0, ooxml_1.resolveTarget)(rels.name, target);
+                    if (drops.has(k)) {
+                        removed.add(id);
+                        return { remove: true };
+                    }
+                    const type = ((0, xml_1.attr)(el, '', 'Type') ?? '').trim().toLowerCase();
+                    if (sheets.has(k) && MACRO_RELATIONSHIPS.has(type))
+                        return { set: new Map([['Type', worksheetRelationship]]) };
+                    return undefined;
+                },
+            };
+            const r = await (0, rewrite_xml_1.partEdits)(zip.read(rels), rels.name, limits, false, plan.parts.get(rels.name), rules);
+            if (r.edits.length)
+                relsEdits.set(rels.name, r.edits);
+            if (removed.size)
+                removedIds.set(source, removed);
+        }
+        let more = false;
+        partEditsByName.clear();
+        // An XPS part names the parts it uses in its markup, so every XPS part is read again once a part goes.
+        const xpsDrops = graph.xps && drops.size > 0;
+        for (const [k, p] of graph.parts) {
+            const removed = removedIds.get(k);
+            const own = plan.parts.get(p.entry.name);
+            if (drops.has(k) || sheets.has(k) || plan.replace.has(k) || !(0, ooxml_1.isXmlType)(p.contentType) || (!removed && !own && !xpsDrops))
+                continue;
+            const rules = {
+                element(el) {
+                    // An XPS element that names a part that went goes with it.
+                    if (xpsDrops && ooxml_1.XPS_NS.has(el.ns.toLowerCase())) {
+                        for (const [, uri] of (0, ooxml_1.xpsResources)(el))
+                            if (!(0, links_1.isAbsoluteTarget)(uri) && drops.has((0, ooxml_1.resolvePartRef)(p.entry.name, uri)))
+                                return { remove: true };
+                    }
+                    if (!removed)
+                        return undefined;
+                    for (const a of el.attributes) {
+                        const ns = a.ns.toLowerCase();
+                        if ((ooxml_1.R_NS.has(ns) || (ns === VML_OFFICE_NS && a.local === 'relid')) && removed.has(a.value)) {
+                            // A hyperlink's text stays. Any other element that names a relationship that went goes with it.
+                            return ooxml_1.WORD_NS.has(el.ns.toLowerCase()) && el.local === 'hyperlink' ? { unwrap: true } : { remove: true };
+                        }
+                    }
+                    return undefined;
+                },
+                // An XPS property element such as Path.Fill holds one value, and goes once that value went.
+                collapses: el => (ooxml_1.SHEET_NS.has(el.ns.toLowerCase()) && LISTS.has(el.local)) || (graph.xps && ooxml_1.XPS_NS.has(el.ns.toLowerCase()) && el.local.includes('.')),
+                word: el => ooxml_1.WORD_NS.has(el.ns.toLowerCase()),
+            };
+            const r = await (0, rewrite_xml_1.partEdits)(zip.read(p.entry), p.entry.name, limits, p.contentType === ooxml_1.TYPE.vml, own, rules);
+            if (r.rootRemoved) {
+                drops.add(k);
+                more = true;
+            }
+            else if (r.edits.length)
+                partEditsByName.set(p.entry.name, r.edits);
+        }
+        if (!more)
+            break;
+    }
+    // The content types of parts that went, and of macro sheets that became worksheets.
+    const overridden = new Set();
+    let prefix = '';
+    const typesRules = {
+        element(el) {
+            if (el.ns.toLowerCase() !== ooxml_1.CONTENT_TYPES_NS)
+                return undefined;
+            if (el.depth === 1)
+                prefix = el.qname.includes(':') ? el.qname.slice(0, el.qname.indexOf(':') + 1) : '';
+            if (el.local !== 'Override')
+                return undefined;
+            const name = (0, xml_1.attr)(el, '', 'PartName');
+            if (name === undefined)
+                return undefined;
+            const k = (0, zip_1.nameKey)(name.replace(/^\//, ''));
+            if (drops.has(k))
+                return { remove: true };
+            if (!sheets.has(k))
+                return undefined;
+            overridden.add(k);
+            return { set: new Map([['ContentType', sheetType(k)]]) };
+        },
+        append: () => [...sheets]
+            .filter(k => !overridden.has(k) && !drops.has(k))
+            .map(k => `<${prefix}Override PartName="/${escapeAttribute(graph.parts.get(k)?.entry.name ?? k)}" ContentType="${sheetType(k)}"/>`)
+            .join(''),
+    };
+    const types = await (0, rewrite_xml_1.partEdits)(zip.read(graph.contentTypes), graph.contentTypes.name, limits, false, plan.parts.get(graph.contentTypes.name), typesRules);
+    const window = new PdfWindow(sink);
+    try {
+        for (const e of zip.entries) {
+            (0, errors_1.checkTime)(run.deadline);
+            const k = (0, zip_1.nameKey)(e.name);
+            if (drops.has(k))
+                continue;
+            const replaced = plan.replace.get(k);
+            const edits = e === graph.contentTypes ? types.edits : (relsEdits.get(e.name) ?? partEditsByName.get(e.name));
+            if (replaced)
+                await window.add(await deflatedEntry(run, e, replaced.read()));
+            else if (sheets.has(k))
+                await window.add(await deflatedEntry(run, e, bytesOf(emptySheet(binarySheet(k), strict))));
+            else if (edits?.length)
+                await window.add(await deflatedEntry(run, e, (0, rewrite_xml_1.splice)(zip.read(e), edits)));
+            else
+                await window.add(copiedEntry(run, zip, e));
+        }
+        await window.end();
+    }
+    finally {
+        await window.dispose();
+    }
+    await window.writer.finish();
+}
+/** An empty worksheet, as XML or as the records of a binary workbook. */
+function emptySheet(binary, strict) {
+    // BrtBeginSheet, BrtBeginSheetData, BrtEndSheetData and BrtEndSheet, each with no data.
+    if (binary)
+        return Uint8Array.of(0x81, 0x01, 0x00, 0x91, 0x01, 0x00, 0x92, 0x01, 0x00, 0x82, 0x01, 0x00);
+    const ns = strict ? 'http://purl.oclc.org/ooxml/spreadsheetml/main' : 'http://schemas.openxmlformats.org/spreadsheetml/2006/main';
+    return Buffer.from(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet xmlns="${ns}"><sheetData/></worksheet>`, 'utf8');
+}
+/** A relative path resolved against a folder of the package, as a key. "." and ".." segments are read. */
+function resolveIn(folder, href) {
+    const out = [];
+    for (const seg of `${folder}${href.trim()}`.split('/')) {
+        if (seg === '..')
+            out.pop();
+        else if (seg !== '.' && seg !== '')
+            out.push(seg);
+    }
+    return (0, zip_1.nameKey)(out.join('/'));
+}
+/**
+ * Writes an OpenDocument package without what the plan removes, with the mimetype entry first, stored and without an
+ * extra field. An entry goes with its manifest entry and every element whose link names it. A package without a
+ * manifest gets one that lists its entries.
+ */
+async function writeOdf(run, zip, plan, format, limits, sink) {
+    const layout = plan.odf;
+    const drops = new Set(plan.drop);
+    const folders = plan.folders;
+    const gone = (k) => drops.has(k) || [...folders].some(f => k.startsWith(f) || `${k}/` === f);
+    for (const e of zip.entries)
+        if (gone((0, zip_1.nameKey)(e.name)))
+            drops.add((0, zip_1.nameKey)(e.name));
+    const xmlEntries = zip.entries.filter(e => !e.directory && e !== layout?.mimetype && e !== layout?.manifest && /\.xml$/i.test(e.name) && !(0, odf_1.folderOf)(e.name));
+    const edits = new Map();
+    for (;;) {
+        let more = false;
+        edits.clear();
+        for (const e of xmlEntries) {
+            const k = (0, zip_1.nameKey)(e.name);
+            const own = plan.parts.get(e.name);
+            if (drops.has(k) || plan.replace.has(k) || (!own && !drops.size))
+                continue;
+            const folder = e.name.includes('/') ? e.name.slice(0, e.name.lastIndexOf('/') + 1) : '';
+            const rules = {
+                element(el) {
+                    const written = (0, odf_1.hrefOf)(el);
+                    // LibreOffice's vnd.sun.star.Package: URLs name an entry too.
+                    const href = written === undefined ? undefined : (/^\s*vnd\.sun\.star\.package:(.*)$/is.exec(written)?.[1] ?? written);
+                    if (href === undefined || !(0, links_1.isInsidePackage)(href))
+                        return undefined;
+                    // A link inside a sub-document may name its entry from the package root or from the sub-document's folder.
+                    return gone((0, odf_1.packagePath)(href)) || gone(resolveIn(folder, href)) ? { remove: true } : undefined;
+                },
+            };
+            const r = await (0, rewrite_xml_1.partEdits)(zip.read(e), e.name, limits, false, own, rules);
+            if (r.rootRemoved) {
+                drops.add(k);
+                more = true;
+            }
+            else if (r.edits.length)
+                edits.set(e.name, r.edits);
+        }
+        if (!more)
+            break;
+    }
+    const manifest = layout?.manifest;
+    if (manifest && drops.size) {
+        const rules = {
+            element(el) {
+                if ((0, odf_1.odfNamespace)(el.ns) !== odf_1.NS.manifest || el.local !== 'file-entry')
+                    return undefined;
+                const path = el.attributes.find(a => a.local === 'full-path' && (0, odf_1.odfNamespace)(a.ns) === odf_1.NS.manifest)?.value;
+                return path !== undefined && path !== '/' && gone((0, odf_1.packagePath)(path)) ? { remove: true } : undefined;
+            },
+        };
+        const r = await (0, rewrite_xml_1.partEdits)(zip.read(manifest), manifest.name, limits, false, plan.parts.get(manifest.name), rules);
+        if (r.edits.length)
+            edits.set(manifest.name, r.edits);
+    }
+    else if (manifest && plan.parts.has(manifest.name)) {
+        const r = await (0, rewrite_xml_1.partEdits)(zip.read(manifest), manifest.name, limits, false, plan.parts.get(manifest.name), { element: () => undefined });
+        if (r.edits.length)
+            edits.set(manifest.name, r.edits);
+    }
+    const window = new PdfWindow(sink);
+    const writer = window.writer;
+    await writer.add('mimetype', Buffer.from(layout?.mediaType || format.mimeType, 'latin1'), { compress: false, dosTime: layout?.mimetype?.dosTime, dosDate: layout?.mimetype?.dosDate });
+    const kept = [];
+    try {
+        for (const e of zip.entries) {
+            (0, errors_1.checkTime)(run.deadline);
+            const k = (0, zip_1.nameKey)(e.name);
+            if (e === layout?.mimetype || drops.has(k))
+                continue;
+            kept.push(e);
+            const replaced = plan.replace.get(k);
+            const own = edits.get(e.name);
+            if (replaced)
+                await window.add(await deflatedEntry(run, e, replaced.read()));
+            else if (own?.length)
+                await window.add(await deflatedEntry(run, e, (0, rewrite_xml_1.splice)(zip.read(e), own)));
+            else
+                await window.add(copiedEntry(run, zip, e));
+        }
+        if (!manifest) {
+            const entries = kept
+                .filter(e => !e.directory)
+                .map(e => `<manifest:file-entry manifest:full-path="${escapeAttribute(e.name)}" manifest:media-type="${/\.xml$/i.test(e.name) ? 'text/xml' : ''}"/>`)
+                .join('');
+            const xml = `<?xml version="1.0" encoding="UTF-8"?>\n<manifest:manifest xmlns:manifest="${odf_1.NS.manifest}"><manifest:file-entry manifest:full-path="/" manifest:media-type="${escapeAttribute(layout?.mediaType || format.mimeType)}"/>${entries}</manifest:manifest>`;
+            await window.add(bytesEntry('META-INF/manifest.xml', Buffer.from(xml, 'utf8')));
+        }
+        await window.end();
+    }
+    finally {
+        await window.dispose();
+    }
+    await writer.finish();
+}
+/** Writes the rewritten package to `sink`, which the caller closes. */
+async function writePackage(run, zip, plan, format, limits, sink) {
+    if (plan.graph)
+        await writeOoxml(run, zip, plan, plan.graph, format, limits, sink);
+    else
+        await writeOdf(run, zip, plan, format, limits, sink);
+}