@patrickdk77/pdf-defuse 0.0.0-stage → 0.1.0

package/dist/crypto.js

@@ -0,0 +1,404 @@
+"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.SecurityHandler = exports.rc4 = exports.Rc4 = void 0;
+const crypto = __importStar(require("node:crypto"));
+const objects_1 = require("./objects");
+const PAD = Buffer.from('28BF4E5E4E758A4164004E56FFFA01082E2E00B6D0683E802F0CA9FE6453697A', 'hex');
+const md5 = (...parts) => {
+    const h = crypto.createHash('md5');
+    for (const p of parts)
+        h.update(p);
+    return h.digest();
+};
+/** RC4 with state, so a stream can be decrypted in chunks. Node 24's OpenSSL 3 refuses RC4, so it is written here. */
+class Rc4 {
+    s = new Uint8Array(256);
+    i = 0;
+    j = 0;
+    constructor(key) {
+        const s = this.s;
+        for (let i = 0; i < 256; i++)
+            s[i] = i;
+        for (let i = 0, j = 0; i < 256; i++) {
+            j = (j + s[i] + key[i % key.length]) & 255;
+            const t = s[i];
+            s[i] = s[j];
+            s[j] = t;
+        }
+    }
+    update(data) {
+        const s = this.s;
+        const out = Buffer.alloc(data.length);
+        let i = this.i;
+        let j = this.j;
+        for (let k = 0; k < data.length; k++) {
+            i = (i + 1) & 255;
+            j = (j + s[i]) & 255;
+            const t = s[i];
+            s[i] = s[j];
+            s[j] = t;
+            out[k] = data[k] ^ s[(s[i] + s[j]) & 255];
+        }
+        this.i = i;
+        this.j = j;
+        return out;
+    }
+}
+exports.Rc4 = Rc4;
+const rc4 = (key, data) => new Rc4(key).update(data);
+exports.rc4 = rc4;
+function aesDecryptWhole(key, data) {
+    if (data.length < 16)
+        return Buffer.alloc(0);
+    const iv = data.subarray(0, 16);
+    const body = data.subarray(16, 16 + Math.floor((data.length - 16) / 16) * 16);
+    if (body.length === 0)
+        return Buffer.alloc(0);
+    const algo = key.length === 16 ? 'aes-128-cbc' : 'aes-256-cbc';
+    try {
+        const d = crypto.createDecipheriv(algo, key, iv);
+        return Buffer.concat([d.update(body), d.final()]);
+    }
+    catch {
+        const d = crypto.createDecipheriv(algo, key, iv);
+        d.setAutoPadding(false);
+        return Buffer.concat([d.update(body), d.final()]);
+    }
+}
+function hash2B(pw, salt, udata, revision) {
+    if (revision === 5)
+        return crypto
+            .createHash('sha256')
+            .update(Buffer.concat([pw, salt, udata]))
+            .digest();
+    let k = crypto
+        .createHash('sha256')
+        .update(Buffer.concat([pw, salt, udata]))
+        .digest();
+    let e = Buffer.alloc(0);
+    for (let round = 0;;) {
+        const k1 = Buffer.concat(new Array(64).fill(Buffer.concat([pw, k, udata])));
+        const c = crypto.createCipheriv('aes-128-cbc', k.subarray(0, 16), k.subarray(16, 32));
+        c.setAutoPadding(false);
+        e = Buffer.concat([c.update(k1), c.final()]);
+        let sum = 0;
+        for (let i = 0; i < 16; i++)
+            sum += e[i];
+        k = crypto
+            .createHash(['sha256', 'sha384', 'sha512'][sum % 3])
+            .update(e)
+            .digest();
+        round++;
+        if (round >= 64 && e[e.length - 1] <= round - 32)
+            break;
+    }
+    return k.subarray(0, 32);
+}
+function aes256NoIv(key, data) {
+    const d = crypto.createDecipheriv('aes-256-cbc', key, Buffer.alloc(16));
+    d.setAutoPadding(false);
+    return Buffer.concat([d.update(data), d.final()]);
+}
+const bytesOf = (v) => (v instanceof objects_1.PdfString ? v.bytes : new Uint8Array(0));
+class SecurityHandler {
+    version;
+    keyBits;
+    fileKey;
+    streamMethod;
+    stringMethod;
+    embeddedFileMethod;
+    encryptMetadata;
+    cryptFilters;
+    unknownFilters;
+    constructor(version, keyBits, fileKey, streamMethod, stringMethod, embeddedFileMethod, encryptMetadata, cryptFilters, 
+    /** Crypt filters with a /CFM this package cannot decrypt, mapped to that /CFM. Harmless until something selects one. */
+    unknownFilters) {
+        this.version = version;
+        this.keyBits = keyBits;
+        this.fileKey = fileKey;
+        this.streamMethod = streamMethod;
+        this.stringMethod = stringMethod;
+        this.embeddedFileMethod = embeddedFileMethod;
+        this.encryptMetadata = encryptMetadata;
+        this.cryptFilters = cryptFilters;
+        this.unknownFilters = unknownFilters;
+    }
+    static open(enc, id0, password) {
+        const filter = enc.name('Filter');
+        if (filter === 'Adobe.PubSec')
+            return { status: 'certificate-handler' };
+        if (filter !== 'Standard')
+            return { status: 'unknown-handler', detail: filter };
+        const V = enc.number('V') ?? 0;
+        const R = enc.number('R') ?? 0;
+        // ISO 32000-2 7.6: /EncryptMetadata, like crypt filters, means something only for V4 and V5.
+        const encryptMetadata = V < 4 || enc.get('EncryptMetadata') !== false;
+        const cryptFilters = new Map([['Identity', 'Identity']]);
+        const unknownFilters = new Map();
+        const cf = enc.get('CF');
+        if (cf instanceof objects_1.PdfDict) {
+            for (const [name, v] of cf.entries()) {
+                if (!(v instanceof objects_1.PdfDict))
+                    continue;
+                const cfm = v.name('CFM') ?? 'None';
+                const m = { V2: 'RC4', AESV2: 'AES128', AESV3: 'AES256', None: 'Identity' }[cfm];
+                if (m)
+                    cryptFilters.set(name, m);
+                else
+                    unknownFilters.set(name, cfm);
+            }
+        }
+        let unusable;
+        const methodFor = (key, fallback) => {
+            if (V < 4)
+                return 'RC4';
+            const n = enc.name(key);
+            if (n === undefined)
+                return fallback ?? 'Identity';
+            const m = cryptFilters.get(n);
+            if (!m)
+                unusable ??= unknownFilters.get(n);
+            return m;
+        };
+        const stm = methodFor('StmF');
+        const str = methodFor('StrF');
+        const eff = methodFor('EFF', stm);
+        if (!stm || !str || !eff)
+            return { status: 'unknown-filter', detail: unusable };
+        const O = bytesOf(enc.get('O'));
+        const U = bytesOf(enc.get('U'));
+        let keyBits;
+        let fileKey;
+        let which = password === '' ? 'empty' : 'user';
+        if (R === 5 || R === 6) {
+            keyBits = 256;
+            const pw = Buffer.from(password, 'utf8').subarray(0, 127);
+            const uKey = () => {
+                if (!hash2B(pw, U.subarray(32, 40), Buffer.alloc(0), R).equals(Buffer.from(U.subarray(0, 32))))
+                    return undefined;
+                return aes256NoIv(hash2B(pw, U.subarray(40, 48), Buffer.alloc(0), R), bytesOf(enc.get('UE')));
+            };
+            const oKey = () => {
+                const u48 = U.subarray(0, 48);
+                if (!hash2B(pw, O.subarray(32, 40), u48, R).equals(Buffer.from(O.subarray(0, 32))))
+                    return undefined;
+                return aes256NoIv(hash2B(pw, O.subarray(40, 48), u48, R), bytesOf(enc.get('OE')));
+            };
+            fileKey = uKey();
+            if (!fileKey && password !== '') {
+                fileKey = oKey();
+                which = 'owner';
+            }
+            if (!fileKey)
+                return { status: 'password-required' };
+        }
+        else if (R >= 2 && R <= 4) {
+            const n = V === 1 ? 5 : V >= 4 ? 16 : (enc.number('Length') ?? 40) / 8;
+            if (!Number.isInteger(n) || n < 5 || n > 16)
+                return { status: 'unknown-filter', detail: `key length ${n * 8}` };
+            keyBits = n * 8;
+            const P = Buffer.alloc(4);
+            // /P is a 32-bit signed integer that some writers store unsigned; the key takes its low 32 bits either way.
+            P.writeInt32LE((enc.number('P') ?? 0) | 0);
+            const keyFor = (paddedUser) => {
+                let h = md5(paddedUser, O.subarray(0, 32), P, id0, R >= 4 && !encryptMetadata ? Buffer.from('ffffffff', 'hex') : Buffer.alloc(0));
+                if (R >= 3)
+                    for (let i = 0; i < 50; i++)
+                        h = md5(h.subarray(0, n));
+                return h.subarray(0, n);
+            };
+            const checkUser = (key) => {
+                if (R === 2)
+                    return (0, exports.rc4)(key, PAD).equals(Buffer.from(U.subarray(0, 32)));
+                let x = (0, exports.rc4)(key, md5(PAD, id0));
+                for (let i = 1; i <= 19; i++)
+                    x = (0, exports.rc4)(Buffer.from(key.map(b => b ^ i)), x);
+                return x.equals(Buffer.from(U.subarray(0, 16)));
+            };
+            const padded = Buffer.concat([Buffer.from(password, 'latin1').subarray(0, 32), PAD]).subarray(0, 32);
+            const asUser = keyFor(padded);
+            if (checkUser(asUser))
+                fileKey = asUser;
+            else if (password !== '') {
+                // Owner password: derive the RC4 key from it, decrypt O to recover the padded user password.
+                let h = md5(padded);
+                if (R >= 3)
+                    for (let i = 0; i < 50; i++)
+                        h = md5(h);
+                const ownerKey = h.subarray(0, n);
+                let userPadded;
+                if (R === 2)
+                    userPadded = (0, exports.rc4)(ownerKey, O.subarray(0, 32));
+                else {
+                    userPadded = Buffer.from(O.subarray(0, 32));
+                    for (let i = 19; i >= 0; i--)
+                        userPadded = (0, exports.rc4)(Buffer.from(ownerKey.map(b => b ^ i)), userPadded);
+                }
+                const k = keyFor(userPadded);
+                if (checkUser(k)) {
+                    fileKey = k;
+                    which = 'owner';
+                }
+            }
+            if (!fileKey)
+                return { status: 'password-required' };
+        }
+        else {
+            return { status: 'unknown-filter', detail: `R=${R}` };
+        }
+        return { status: 'ok', password: which, handler: new SecurityHandler(V, keyBits, fileKey, stm, str, eff, encryptMetadata, cryptFilters, unknownFilters) };
+    }
+    keyCache = new Map();
+    objectKey(num, gen, method) {
+        if (method === 'AES256')
+            return Buffer.from(this.fileKey);
+        const ck = `${num} ${gen} ${method}`;
+        const hit = this.keyCache.get(ck);
+        if (hit)
+            return hit;
+        if (this.keyCache.size > 256)
+            this.keyCache.clear();
+        const ext = Buffer.from([num & 255, (num >> 8) & 255, (num >> 16) & 255, gen & 255, (gen >> 8) & 255]);
+        const key = md5(this.fileKey, ext, method === 'AES128' ? Buffer.from('sAlT') : Buffer.alloc(0)).subarray(0, Math.min(this.fileKey.length + 5, 16));
+        this.keyCache.set(ck, key);
+        return key;
+    }
+    decryptWith(method, data, num, gen) {
+        if (method === 'Identity')
+            return data;
+        const key = this.objectKey(num, gen, method);
+        return method === 'RC4' ? (0, exports.rc4)(key, data) : aesDecryptWhole(key, data);
+    }
+    /** The crypt method for a stream, honoring a /Crypt filter in its own Filter array and the embedded-file default. */
+    methodForStream(stream) {
+        const dict = stream.dict;
+        const type = dict.name('Type');
+        if (type === 'XRef')
+            return 'Identity';
+        if (type === 'Metadata' && !this.encryptMetadata)
+            return 'Identity';
+        const f = dict.get('Filter');
+        const filters = f instanceof objects_1.PdfName ? [f] : Array.isArray(f) ? f : [];
+        // Before V4 there are no crypt filters, so a /Crypt entry cannot exempt a stream from the document's method.
+        const ci = this.version >= 4 ? filters.findIndex(x => x instanceof objects_1.PdfName && x.name === 'Crypt') : -1;
+        if (ci >= 0) {
+            const p = dict.get('DecodeParms');
+            const parms = Array.isArray(p) ? p[ci] : p;
+            const name = parms instanceof objects_1.PdfDict ? (parms.name('Name') ?? 'Identity') : 'Identity';
+            const unknown = this.unknownFilters.get(name);
+            if (unknown !== undefined)
+                throw new Error(`Crypt filter ${name} uses the unsupported method ${unknown}`);
+            return this.cryptFilters.get(name) ?? 'Identity';
+        }
+        if (type === 'EmbeddedFile')
+            return this.embeddedFileMethod;
+        return this.streamMethod;
+    }
+    /**
+     * Plaintext length of a stream, read without decrypting the whole body. For AES the last two
+     * blocks are decrypted to learn the padding length.
+     */
+    async plainLength(stream, num, gen, readRaw) {
+        const method = this.methodForStream(stream);
+        const len = stream.length;
+        if (method === 'Identity' || method === 'RC4')
+            return len;
+        if (len < 32)
+            return 0;
+        const full = 16 + Math.floor((len - 16) / 16) * 16;
+        const tail = await readRaw(full - 32, 32);
+        const key = this.objectKey(num, gen, method);
+        const d = crypto.createDecipheriv(key.length === 16 ? 'aes-128-ecb' : 'aes-256-ecb', key, null);
+        d.setAutoPadding(false);
+        const last = Buffer.concat([d.update(tail.subarray(16, 32)), d.final()]);
+        for (let i = 0; i < 16; i++)
+            last[i] ^= tail[i];
+        const pad = last[15];
+        const valid = pad >= 1 && pad <= 16 && last.subarray(16 - pad).every(b => b === pad);
+        return full - 16 - (valid ? pad : 0);
+    }
+    /** A decryptor that emits exactly `plainLength` bytes across all chunks. */
+    chunkDecryptor(stream, num, gen, plainLength) {
+        const method = this.methodForStream(stream);
+        if (method === 'Identity')
+            return { update: c => Buffer.from(c), final: () => Buffer.alloc(0) };
+        const key = this.objectKey(num, gen, method);
+        if (method === 'RC4') {
+            const r = new Rc4(key);
+            return { update: c => r.update(c), final: () => Buffer.alloc(0) };
+        }
+        let iv = null;
+        let pending = Buffer.alloc(0);
+        let decipher = null;
+        let emitted = 0;
+        const take = (b) => {
+            const room = plainLength - emitted;
+            const out = b.length > room ? b.subarray(0, room) : b;
+            emitted += out.length;
+            return out;
+        };
+        return {
+            update(chunk) {
+                let c = Buffer.from(chunk);
+                if (!iv) {
+                    pending = Buffer.concat([pending, c]);
+                    if (pending.length < 16)
+                        return Buffer.alloc(0);
+                    iv = pending.subarray(0, 16);
+                    c = pending.subarray(16);
+                    decipher = crypto.createDecipheriv(key.length === 16 ? 'aes-128-cbc' : 'aes-256-cbc', key, iv);
+                    decipher.setAutoPadding(false);
+                }
+                if (!decipher)
+                    throw new Error('No AES decipher after the IV was read');
+                return take(decipher.update(c));
+            },
+            final() {
+                if (!decipher)
+                    return Buffer.alloc(0);
+                let rest;
+                try {
+                    rest = decipher.final();
+                }
+                catch {
+                    rest = Buffer.alloc(0);
+                }
+                return take(rest);
+            },
+        };
+    }
+}
+exports.SecurityHandler = SecurityHandler;

package/dist/data-plugins.d.ts

@@ -0,0 +1,28 @@
+import type { ByteSink, ContainedFilePlugin } from './types';
+/** What the CSV and TSV plugins do with a cell a spreadsheet would read as a formula. */
+export type FormulaHandling = 'escape' | 'keep' | 'remove';
+export interface DelimitedOptions {
+    /**
+     * 'escape', the default, puts an apostrophe before the cell so a spreadsheet shows it as text. 'keep' leaves
+     * it. 'remove' drops the whole file. It is read for each file, so it can still change after the plugin is made.
+     */
+    formulas?: FormulaHandling;
+}
+/**
+ * Reads CSV or TSV bytes and counts the cells a spreadsheet would run as a formula: those starting with =, +, -,
+ * @, tab or CR, except a plain number or a lone sign. Quoting follows RFC 4180, and a stray quote counts as text,
+ * as spreadsheets take it. With a sink, writes the file with an apostrophe before each such cell and every other
+ * byte unchanged. Returns the count, or -1 when the bytes are not UTF-8 text or a quoted cell never closes.
+ */
+export declare function scanDelimited(chunks: AsyncIterable<Uint8Array>, delimiter: number, sink?: ByteSink): Promise<number>;
+/** Keeps attached CSV files that are UTF-8 text, and escapes cells a spreadsheet would run as formulas. */
+export declare function csvPlugin(options?: DelimitedOptions): ContainedFilePlugin;
+/** The same for tab-separated files. */
+export declare function tsvPlugin(options?: DelimitedOptions): ContainedFilePlugin;
+/**
+ * True when the bytes are exactly one JSON value (RFC 8259) in UTF-8, after an optional byte order mark. Reads in
+ * chunks, keeping one byte per open container, so memory does not grow with the file.
+ */
+export declare function isJson(chunks: AsyncIterable<Uint8Array>): Promise<boolean>;
+/** Keeps attached JSON files that parse, and removes the rest. */
+export declare function jsonPlugin(): ContainedFilePlugin;