@patrickdk77/office-defuse 0.1.1 → 0.2.1

package/dist/ole.js

@@ -1,14 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.families = families;
+exports.mainFamily = mainFamily;
+exports.compoundFormat = compoundFormat;
+exports.openEncryptedPackage = openEncryptedPackage;
 exports.inspectCompound = inspectCompound;
 const errors_1 = require("./errors");
 const msg_1 = require("./msg");
 const objects_1 = require("./objects");
 const offcrypto_1 = require("./offcrypto");
 const package_1 = require("./package");
+const plan_1 = require("./plan");
 const ppt_1 = require("./ppt");
 const types_1 = require("./types");
+const vsd_1 = require("./vsd");
 const word_1 = require("./word");
 const xls_1 = require("./xls");
 const zip_1 = require("./zip");
@@ -41,10 +46,10 @@ function families(cfb) {
     return out;
 }
 /**
- * Inspects a compound file: the rules every compound file gets, over its whole tree, and then those of the format
- * its root names.
+ * The family whose format a compound file holds, by the streams and storages at its root. Throws for a root that
+ * holds no Office document, or the documents of two families.
  */
-async function inspectCompound(ctx, cfb) {
+function mainFamily(cfb) {
     const found = families(cfb);
     // Word 2007 writes a Word document beside an encrypted package, for readers that cannot decrypt it.
     const main = found.filter(x => !(x === 'word' && found.includes('encrypted')));
@@ -52,76 +57,111 @@ async function inspectCompound(ctx, cfb) {
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.AmbiguousFormat, `The compound file holds ${main.join(' and ')} streams`, { reason: `${main.join(' and ')} streams` });
     if (main.length === 0)
         throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The compound file holds no Office document stream', { reason: 'a compound file of another kind' });
-    const family = main[0];
-    ctx.format = formatOf(family, cfb);
-    await (0, objects_1.compoundRules)(ctx, cfb, '', false);
-    const stream = (name) => {
-        const e = cfb.child(cfb.root, name);
-        return e?.kind === 'stream' ? e : undefined;
-    };
+    return main[0];
+}
+/** A stream at the root of a compound file, by name, ignoring case. */
+const rootStream = (cfb, name) => {
+    const e = cfb.child(cfb.root, name);
+    return e?.kind === 'stream' ? e : undefined;
+};
+/**
+ * The format of a compound file of `family`. A Word document is a template when its FIB says so, and a workbook a
+ * template or an add-in when its globals do; both are read without a password. An encrypted package names no format
+ * until it is decrypted, so for one this is undefined.
+ */
+async function compoundFormat(cfb, family, deadline) {
+    switch (family) {
+        case 'word': {
+            const word = rootStream(cfb, 'WordDocument');
+            return word && (await (0, word_1.isWordTemplate)(cfb, word)) ? f('dot', 'application/msword') : f('doc', 'application/msword');
+        }
+        case 'excel': {
+            // Excel 97 to 2003 reads Workbook, and Excel 5.0 and 95 read Book. A file can hold both.
+            let template = false;
+            let addIn = false;
+            for (const name of ['Workbook', 'Book']) {
+                const s = rootStream(cfb, name);
+                if (!s)
+                    continue;
+                const kind = await (0, xls_1.workbookKind)(cfb, s, deadline);
+                template ||= kind.template;
+                addIn ||= kind.addIn;
+            }
+            return addIn ? f('xla', 'application/vnd.ms-excel') : template ? f('xlt', 'application/vnd.ms-excel') : f('xls', 'application/vnd.ms-excel');
+        }
+        case 'powerpoint':
+            return f('ppt', 'application/vnd.ms-powerpoint');
+        case 'visio':
+            return f('vsd', 'application/vnd.visio');
+        case 'outlook':
+            return cfb.root.clsid === '0006F046-0000-0000-C000-000000000046' ? f('oft', 'application/vnd.ms-outlook') : f('msg', 'application/vnd.ms-outlook');
+        case 'publisher':
+            return f('pub', 'application/x-mspublisher');
+        case 'project':
+            return f('mpp', 'application/vnd.ms-project');
+        default:
+            // An encrypted package names its format only once it is decrypted.
+            return undefined;
+    }
+}
+/**
+ * Decrypts the package of an encrypted compound file with the run's passwords, then VelvetSweatshop, and reads it as
+ * a ZIP archive. Throws ENCRYPTED/PASSWORD_REQUIRED when no password opens it.
+ */
+async function openEncryptedPackage(ctx, cfb) {
+    const info = rootStream(cfb, 'EncryptionInfo');
+    const pkg = rootStream(cfb, 'EncryptedPackage');
+    if (!info || !pkg)
+        throw new errors_1.StopError(types_1.OfficeCategory.Package, types_1.OfficeDetail.Unrecognized, 'The compound file holds no encrypted package', { reason: 'no EncryptionInfo and EncryptedPackage streams' });
+    const { source } = await (0, offcrypto_1.openPackage)(ctx, cfb, info, pkg);
+    return zip_1.ZipArchive.open(source, ctx.settings, ctx.settings.deadline);
+}
+/**
+ * Inspects a compound file: the rules every compound file gets, over its whole tree, and then those of the format
+ * its root names.
+ */
+async function inspectCompound(ctx, cfb) {
+    const family = mainFamily(cfb);
+    ctx.format = await compoundFormat(cfb, family, ctx.settings.deadline);
+    const plan = new plan_1.CompoundPlan();
+    if (family !== 'encrypted')
+        ctx.run.output = { kind: 'cfb', cfb, plan };
+    await (0, objects_1.compoundRules)(ctx, cfb, '', false, plan);
+    const stream = (name) => rootStream(cfb, name);
     // Beside an encrypted package, Word 2007 writes a WordDocument stream for older readers, of zeros in the files at
     // hand. Those readers read it if it holds a document, so it gets the Word rules when it does.
     const word = stream('WordDocument');
-    if (word) {
-        const r = await (0, word_1.wordRules)(ctx, cfb, word, family === 'encrypted');
-        if (r?.template && family === 'word')
-            ctx.format = f('dot', 'application/msword');
-    }
+    if (word)
+        await (0, word_1.wordRules)(ctx, cfb, word, family === 'encrypted');
     if (family === 'excel') {
-        // Excel 97 to 2003 reads Workbook, and Excel 5.0 and 95 read Book. A file can hold both.
-        let template = false;
-        let addIn = false;
         for (const name of ['Workbook', 'Book']) {
             const s = stream(name);
-            if (!s)
-                continue;
-            const r = await (0, xls_1.excelRules)(ctx, cfb, s, offcrypto_1.unlockWorkbook);
-            template ||= r.template;
-            addIn ||= r.addIn;
+            if (s)
+                await (0, xls_1.excelRules)(ctx, cfb, s, offcrypto_1.unlockWorkbook);
         }
-        if (addIn)
-            ctx.format = f('xla', 'application/vnd.ms-excel');
-        else if (template)
-            ctx.format = f('xlt', 'application/vnd.ms-excel');
         // Excel keeps the data of a workbook's ActiveX controls in one Ctls stream.
         const controls = stream('Ctls');
-        if (controls && controls.size > 0)
-            ctx.report(types_1.OfficeCategory.Control, types_1.OfficeDetail.ActiveX, controls.name, { stream: controls.name });
+        if (controls && controls.size > 0 && ctx.report(types_1.OfficeCategory.Control, types_1.OfficeDetail.ActiveX, controls.name, { stream: controls.name }).action === 'strip')
+            plan.drop.add(controls);
     }
     if (family === 'outlook')
-        await (0, msg_1.messageRules)(ctx, cfb, cfb.root);
+        await (0, msg_1.messageRules)(ctx, cfb, cfb.root, 0, plan);
     const ppt = stream('PowerPoint Document');
     if (family === 'powerpoint' && ppt)
         await (0, ppt_1.powerPointRules)(ctx, cfb, ppt);
-    const info = stream('EncryptionInfo');
-    const pkg = stream('EncryptedPackage');
-    if (family === 'encrypted' && info && pkg) {
+    const visio = stream('VisioDocument');
+    if (family === 'visio' && visio)
+        await (0, vsd_1.visioRules)(ctx, cfb, visio);
+    if (family === 'encrypted') {
         // The package goes through the OOXML rules once a password opens it, and names the format.
-        const { source } = await (0, offcrypto_1.openPackage)(ctx, cfb, info, pkg);
-        const zip = await zip_1.ZipArchive.open(source, ctx.settings, ctx.settings.deadline);
+        const zip = await openEncryptedPackage(ctx, cfb);
+        const location = stream('EncryptedPackage')?.name ?? 'EncryptedPackage';
         for (const n of zip.notes)
-            ctx.report(types_1.OfficeCategory.Container, n.detail, pkg.name, { bytes: n.bytes });
-        await (0, package_1.inspectPackage)(ctx.withZip(zip));
-    }
-}
-function formatOf(family, cfb) {
-    switch (family) {
-        case 'word':
-            return f('doc', 'application/msword');
-        case 'excel':
-            return f('xls', 'application/vnd.ms-excel');
-        case 'powerpoint':
-            return f('ppt', 'application/vnd.ms-powerpoint');
-        case 'visio':
-            return f('vsd', 'application/vnd.visio');
-        case 'outlook':
-            return cfb.root.clsid === '0006F046-0000-0000-C000-000000000046' ? f('oft', 'application/vnd.ms-outlook') : f('msg', 'application/vnd.ms-outlook');
-        case 'publisher':
-            return f('pub', 'application/x-mspublisher');
-        case 'project':
-            return f('mpp', 'application/vnd.ms-project');
-        default:
-            // An encrypted package names its format only once it is decrypted.
-            return undefined;
+            ctx.report(types_1.OfficeCategory.Container, n.detail, location, { bytes: n.bytes });
+        // The rewrite writes the package decrypted, since office-defuse does not encrypt.
+        const zctx = ctx.withZip(zip);
+        await (0, package_1.inspectPackage)(zctx);
+        if (ctx.format)
+            ctx.run.output = { kind: 'zip', zip, plan: zctx.plan, format: ctx.format };
     }
 }

package/dist/oleobj.d.ts

@@ -54,6 +54,8 @@ export interface PackagedFile {
     /** False when the data names a file it does not hold, a link. */
     embedded: boolean;
     size: number;
+    /** Where the file's bytes start in the native data. */
+    dataAt: number;
 }
 /**
  * Packager's native data, as oleobj reads it: a 16-bit type, the label and source path ended by NULs, eight bytes,
@@ -70,5 +72,14 @@ export interface Ole1Object {
     itemName: string;
     /** The native data of an embedded object. */
     data?: Uint8Array;
+    /** Where the native data starts in the object's bytes, after the size before it. */
+    dataAt?: number;
 }
 export declare function parseOle1(b: Uint8Array): Ole1Object | undefined;
+/**
+ * Data that holds a 32-bit size at `dataAt - 4` and that many bytes at `dataAt`, with `data` in their place and the
+ * size set to match. What came before and after stays. Packager's native data and an OLE 1.0 object have this layout.
+ */
+export declare function replaceSized(bytes: Uint8Array, dataAt: number, oldSize: number, data: Uint8Array): Uint8Array;
+/** A stream that starts with the size of what follows, such as Ole10Native, around `data`. */
+export declare const sizedStream: (data: Uint8Array) => Buffer<ArrayBuffer>;

package/dist/oleobj.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.utf16 = exports.latin1 = exports.ByteReader = exports.Truncated = void 0;
+exports.sizedStream = exports.utf16 = exports.latin1 = exports.ByteReader = exports.Truncated = void 0;
 exports.bounded = bounded;
 exports.parseCompObj = parseCompObj;
 exports.readMoniker = readMoniker;
 exports.parseOleStream = parseOleStream;
 exports.parsePackage = parsePackage;
 exports.parseOle1 = parseOle1;
+exports.replaceSized = replaceSized;
 const cfb_1 = require("./cfb");
 /** Thrown by ByteReader when a structure runs past the end of its bytes. Parsers catch it and keep what they read. */
 class Truncated extends Error {
@@ -177,7 +178,7 @@ function parsePackage(b) {
         const sourcePath = r.ansiz();
         r.skip(8);
         const tempPath = r.ansiz();
-        return bounded(() => ({ fileName, sourcePath, tempPath, embedded: true, size: r.u32() }), () => ({ fileName, sourcePath, tempPath, embedded: false, size: 0 }));
+        return bounded(() => ({ fileName, sourcePath, tempPath, embedded: true, size: r.u32(), dataAt: r.pos }), () => ({ fileName, sourcePath, tempPath, embedded: false, size: 0, dataAt: r.pos }));
     }, () => undefined);
 }
 function parseOle1(b) {
@@ -193,6 +194,22 @@ function parseOle1(b) {
         if (formatId === 1)
             return { formatId, className, topicName, itemName };
         const size = r.u32();
-        return { formatId, className, topicName, itemName, data: r.bytes(Math.min(size, r.left)) };
+        const dataAt = r.pos;
+        return { formatId, className, topicName, itemName, data: r.bytes(Math.min(size, r.left)), dataAt };
     }, () => undefined);
 }
+const le32 = (n) => {
+    const b = Buffer.alloc(4);
+    b.writeUInt32LE(n >>> 0);
+    return b;
+};
+/**
+ * Data that holds a 32-bit size at `dataAt - 4` and that many bytes at `dataAt`, with `data` in their place and the
+ * size set to match. What came before and after stays. Packager's native data and an OLE 1.0 object have this layout.
+ */
+function replaceSized(bytes, dataAt, oldSize, data) {
+    return Buffer.concat([bytes.subarray(0, dataAt - 4), le32(data.length), data, bytes.subarray(Math.min(bytes.length, dataAt + oldSize))]);
+}
+/** A stream that starts with the size of what follows, such as Ole10Native, around `data`. */
+const sizedStream = (data) => Buffer.concat([le32(data.length), data]);
+exports.sizedStream = sizedStream;

package/dist/ooxml.d.ts

@@ -1,8 +1,114 @@
 import { type ZipContext } from './context';
+import { type Format } from './formats';
+import { type XmlElement } from './xml';
 import { type ZipEntry } from './zip';
+export declare const CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types";
+export declare const RELS_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+/** The relationship types that name an XPS package's FixedDocumentSequence, lowercased. */
+export declare const XPS_MAIN: {
+    xps: string;
+    oxps: string;
+};
+/** The XPS and OpenXPS markup namespaces, lowercased. */
+export declare const XPS_NS: Set<string>;
+/** Relationship types, lowercased, as OPC compares them without regard to case. */
+export declare const REL: {
+    main: Set<string>;
+    hyperlink: Set<string>;
+    template: Set<string>;
+    image: Set<string>;
+    frame: Set<string>;
+    subDocument: Set<string>;
+    workbook: Set<string>;
+};
+/** Content types, lowercased. */
+export declare const TYPE: {
+    vba: Set<string>;
+    macrosheet: Set<string>;
+    ole: Set<string>;
+    control: Set<string>;
+    controlBinary: Set<string>;
+    vml: string;
+    xlsbExternalLink: string;
+};
+/** Whether the rules read a part of this content type as XML. */
+export declare const isXmlType: (ct: string | undefined) => boolean;
+export declare const WORD_NS: Set<string>;
+export declare const SHEET_NS: Set<string>;
+export declare const R_NS: Set<string>;
+export interface Relationship {
+    id: string;
+    type: string;
+    target: string;
+    external: boolean;
+}
+export interface Part {
+    entry: ZipEntry;
+    contentType?: string;
+    /** The AS bits of the relationship types that reach the part. */
+    reachedAs: number;
+    /** A relationship of an ActiveX control part reaches it, so it is that control's binary. */
+    claimed: boolean;
+    /** The parts its own relationships reach. */
+    targets: Set<Part>;
+    ole: boolean;
+}
+/** What the rewrite needs of an OOXML package: its parts, which part each relationships part belongs to, and the roots. */
+export interface OoxmlGraph {
+    contentTypes: ZipEntry;
+    parts: Map<string, Part>;
+    relsOf: Map<string, ZipEntry>;
+    /** The parts the package relationships reach. */
+    roots: Set<Part>;
+    /** The package uses the relationship types of Strict OOXML. */
+    strict: boolean;
+    /** The package is XPS or OpenXPS, whose parts name the parts they use in attributes. */
+    xps: boolean;
+}
+/** The key of the part a relationships part belongs to, '' for the package, or undefined for any other part. */
+export declare const relsSource: (relsName: string) => string | undefined;
+/**
+ * Resolves an internal target against the folder of the part it belongs to, as RFC 3986 resolves a relative
+ * reference: a ".." at the root of the package stays at the root. LibreOffice writes "../customXml/item1.xml" in the
+ * package relationships of workbooks it saves.
+ */
+export declare function resolveTarget(relsName: string, target: string): string;
+/** A reference in an XPS part to another part: an absolute part name, or a path relative to the part's folder. */
+export declare function resolvePartRef(part: string, ref: string): string;
+/**
+ * The resources an XPS element names in its attributes, as the attribute and the URI: a document, page or resource
+ * dictionary's Source, a font's FontUri, an image brush's image and profile, and a ContextColor's profile.
+ */
+export declare function xpsResources(el: XmlElement): Array<[string, string]>;
+/** Reads a relationships part and hands each relationship to `each` as it is read. Ids given twice are reported. */
+export declare function readRelationships(ctx: ZipContext, entry: ZipEntry, each: (r: Relationship) => void): Promise<void>;
+/** An OOXML package's parts, typed by its [Content_Types].xml, and its relationships parts by the key of the part each belongs to. */
+export interface OoxmlParts {
+    parts: Map<string, Part>;
+    relsOf: Map<string, ZipEntry>;
+}
+/** Reads [Content_Types].xml and types each part by it. Directory entries are neither parts nor relationships parts. */
+export declare function readParts(ctx: ZipContext, contentTypes: ZipEntry): Promise<OoxmlParts>;
+/** The format the package relationships name, and the relationship types they use. */
+export interface OoxmlMain {
+    format: Format;
+    /** The package uses the relationship types of Strict OOXML. */
+    strict: boolean;
+    /** The package is XPS or OpenXPS. */
+    xps: boolean;
+}
+/**
+ * Reads the package relationships and names the format by the one main part they name: by its content type, or for
+ * XPS by the relationship type too, since XPS and OpenXPS share their content types. `each` sees every package
+ * relationship as it is read. Throws when no main part, or more than one, is named, or its format is unknown.
+ */
+export declare function readMain(ctx: ZipContext, { parts, relsOf }: OoxmlParts, each?: (rels: ZipEntry, r: Relationship) => void): Promise<OoxmlMain>;
+/** Names an OOXML package's format as its inspection does, reading only [Content_Types].xml and the package relationships. */
+export declare function nameOoxml(ctx: ZipContext, contentTypes: ZipEntry): Promise<Format>;
 /**
  * Inspects an OOXML package. The package relationships come first, since they name the main part and so the format.
  * Then each part is read in archive order, followed by its relationships, which are reported as they are read and
- * leave behind only which parts they reach and how.
+ * leave behind only which parts they reach and how. The run names `outer` as the format when given, as for a Flat
+ * OPC package unpacked into a ZIP archive, and the package's own format is returned.
  */
-export declare function inspectOoxml(ctx: ZipContext, contentTypes: ZipEntry): Promise<void>;
+export declare function inspectOoxml(ctx: ZipContext, contentTypes: ZipEntry, outer?: Format): Promise<Format>;