@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/sniff.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTarHeader = isTarHeader;
+exports.sniffType = sniffType;
+exports.family = family;
+exports.extensionOf = extensionOf;
+exports.typeFromName = typeFromName;
+exports.typesDisagree = typesDisagree;
+// Copied from pdf-defuse src/sniff.ts. Changed: sniffType tries the signatures at the start of the file before a PDF
+// header further in, as file-defuse does, and knows the archive formats and RTF. The extension table and the families
+// know them too. extensionOf trims trailing dots and spaces with a loop, since /[. ]+$/ backtracks on long runs.
+const lzma_sniff_1 = require("./lzma-sniff");
+const names_1 = require("./names");
+/** The value of an octal field of a tar header: digits after any spaces, up to a space or NUL. */
+function octal(b, start, length) {
+    let i = start;
+    const end = start + length;
+    while (i < end && b[i] === 0x20)
+        i++;
+    let v = 0;
+    let digits = 0;
+    for (; i < end && b[i] >= 0x30 && b[i] <= 0x37; i++, digits++)
+        v = v * 8 + (b[i] - 0x30);
+    if (digits === 0)
+        return undefined;
+    for (; i < end; i++)
+        if (b[i] !== 0x20 && b[i] !== 0)
+            return undefined;
+    return v;
+}
+/**
+ * True when `block` is a tar header: its checksum field matches the sum of its bytes, counted unsigned or, as some old
+ * writers did, signed, with the field itself counted as spaces. An all-zero block is the end of an archive, not a header.
+ */
+function isTarHeader(block) {
+    if (block.length < 512)
+        return false;
+    const stored = octal(block, 148, 8);
+    if (stored === undefined)
+        return false;
+    let unsigned = 0;
+    let signed = 0;
+    for (let i = 0; i < 512; i++) {
+        const b = i >= 148 && i < 156 ? 0x20 : block[i];
+        unsigned += b;
+        signed += b > 127 ? b - 256 : b;
+    }
+    return unsigned !== 8 * 0x20 && (stored === unsigned || stored === signed);
+}
+const at = (b, offset, bytes) => bytes.every((x, i) => b[offset + i] === x);
+/** Identifies a file type from its first bytes. Returns a MIME type or undefined. */
+function sniffType(head) {
+    const b = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
+    const s = b.subarray(0, 1024).toString('latin1');
+    if (s.startsWith('%PDF-'))
+        return 'application/pdf';
+    if (b[0] === 0x50 && b[1] === 0x4b && (b[2] === 0x03 || b[2] === 0x05 || b[2] === 0x07))
+        return 'application/zip';
+    if (b[0] === 0x1f && b[1] === 0x8b)
+        return 'application/gzip';
+    if (s.startsWith('BZh') && b[3] >= 0x31 && b[3] <= 0x39)
+        return 'application/x-bzip2';
+    if (at(b, 0, [0x28, 0xb5, 0x2f, 0xfd]) || (at(b, 1, [0x2a, 0x4d, 0x18]) && (b[0] & 0xf0) === 0x50))
+        return 'application/zstd';
+    if (s.startsWith('MSCF\0\0\0\0'))
+        return 'application/vnd.ms-cab-compressed';
+    if (s.startsWith('{\\rt'))
+        return 'application/rtf';
+    if (at(b, 0, [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]))
+        return 'application/x-7z-compressed';
+    if (at(b, 0, [0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00]))
+        return 'application/x-xz';
+    if (b[0] === 0x89 && s.startsWith('\x89PNG'))
+        return 'image/png';
+    if (b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff)
+        return 'image/jpeg';
+    if (s.startsWith('GIF87a') || s.startsWith('GIF89a'))
+        return 'image/gif';
+    if (b[0] === 0xd0 && b[1] === 0xcf && b[2] === 0x11 && b[3] === 0xe0)
+        return 'application/x-ole-storage';
+    if (s.startsWith('MZ'))
+        return 'application/x-msdownload';
+    if (s.startsWith('\x7fELF'))
+        return 'application/x-executable';
+    if (isTarHeader(b))
+        return 'application/x-tar';
+    // Zeros pass the .lzma header test, and zero padding is no format.
+    if ((0, lzma_sniff_1.looksLikeLzma)(b) && !b.subarray(0, 13).every(x => x === 0))
+        return 'application/x-lzma';
+    // PDF readers accept the header anywhere in the first 1024 bytes.
+    if (s.includes('%PDF-'))
+        return 'application/pdf';
+    const text = s.replace(/^\xef\xbb\xbf/, '').trimStart();
+    if (/^<svg[\s>/]/i.test(text) || (/^<\?xml/i.test(text) && /<svg[\s>/]/i.test(s)))
+        return 'image/svg+xml';
+    if (/^<\?xml/i.test(text))
+        return 'application/xml';
+    if (/^<!doctype html|^<html[\s>]/i.test(text))
+        return 'text/html';
+    return undefined;
+}
+const EXT = {
+    pdf: 'application/pdf',
+    zip: 'application/zip',
+    docx: 'application/zip',
+    xlsx: 'application/zip',
+    pptx: 'application/zip',
+    odt: 'application/zip',
+    ods: 'application/zip',
+    odp: 'application/zip',
+    epub: 'application/zip',
+    jar: 'application/zip',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    xml: 'application/xml',
+    html: 'text/html',
+    htm: 'text/html',
+    doc: 'application/x-ole-storage',
+    xls: 'application/x-ole-storage',
+    ppt: 'application/x-ole-storage',
+    msg: 'application/x-ole-storage',
+    exe: 'application/x-msdownload',
+    dll: 'application/x-msdownload',
+    csv: 'text/csv',
+    tsv: 'text/tab-separated-values',
+    tab: 'text/tab-separated-values',
+    json: 'application/json',
+    gz: 'application/gzip',
+    tgz: 'application/gzip',
+    bz2: 'application/x-bzip2',
+    tbz: 'application/x-bzip2',
+    tbz2: 'application/x-bzip2',
+    zst: 'application/zstd',
+    tzst: 'application/zstd',
+    tar: 'application/x-tar',
+    cab: 'application/vnd.ms-cab-compressed',
+    '7z': 'application/x-7z-compressed',
+    xz: 'application/x-xz',
+    txz: 'application/x-xz',
+    lzma: 'application/x-lzma',
+    tlz: 'application/x-lzma',
+    br: 'application/x-brotli',
+    rtf: 'application/rtf',
+};
+/** Maps MIME types that share a container format, and common aliases of one type, onto one family. */
+function family(mime) {
+    const m = mime.toLowerCase().split(';')[0].trim();
+    if (m === 'image/jpg' || m === 'image/pjpeg')
+        return 'image/jpeg';
+    if (m === 'image/x-png')
+        return 'image/png';
+    if (m === 'application/x-pdf')
+        return 'application/pdf';
+    if (m === 'application/zip' ||
+        m === 'application/x-zip-compressed' ||
+        m === 'application/x-zip' ||
+        m.includes('openxmlformats') ||
+        m.includes('opendocument') ||
+        m === 'application/epub+zip' ||
+        m === 'application/java-archive')
+        return 'zip';
+    if (m === 'application/x-gzip' || m === 'application/gzip')
+        return 'gzip';
+    if (m === 'application/x-bzip2' || m === 'application/x-bzip')
+        return 'bzip2';
+    if (m === 'application/zstd' || m === 'application/x-zstd')
+        return 'zstd';
+    if (m === 'image/svg+xml')
+        return 'svg';
+    if (m === 'application/xml' || m === 'text/xml')
+        return 'xml';
+    if (m === 'application/msword' || m === 'application/vnd.ms-excel' || m === 'application/vnd.ms-powerpoint' || m === 'application/x-ole-storage' || m === 'application/vnd.ms-outlook')
+        return 'ole';
+    return m;
+}
+/**
+ * A file name's extension, lowercased. Windows drops trailing dots and spaces when it saves a file, so the extension
+ * of "page.html." is html.
+ */
+function extensionOf(name) {
+    return /\.([^./\\]+)$/.exec((0, names_1.trimEnd)(name ?? '', '. '))?.[1].toLowerCase();
+}
+function typeFromName(name) {
+    const ext = extensionOf(name);
+    // Only the table's own entries: "x.constructor" names no type.
+    return ext !== undefined && Object.hasOwn(EXT, ext) ? EXT[ext] : undefined;
+}
+/** Families sniffType has a signature for. Content that claims one of them and matches no signature is not what it claims. */
+const SNIFFABLE = new Set([
+    'application/pdf',
+    'zip',
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'ole',
+    'application/x-msdownload',
+    'application/x-executable',
+    'svg',
+    'xml',
+    'text/html',
+    'gzip',
+    'bzip2',
+    'zstd',
+    'application/x-tar',
+    'application/vnd.ms-cab-compressed',
+    'application/x-7z-compressed',
+    'application/x-xz',
+    'application/x-lzma',
+]);
+/**
+ * True when any two of the declared type, the name's extension and the sniffed content contradict each other, or
+ * when the declared type or the name claims a type sniffType recognizes and the content matched no signature.
+ */
+function typesDisagree(declared, name, sniffed) {
+    const claimed = [declared, typeFromName(name)].filter((t) => t !== undefined && t !== '' && family(t) !== 'application/octet-stream').map(family);
+    const all = sniffed ? [...claimed, family(sniffed)] : claimed;
+    const same = (a, b) => a === b || (a === 'svg' && b === 'xml') || (a === 'xml' && b === 'svg');
+    if (all.some(a => all.some(b => !same(a, b))))
+        return true;
+    return !sniffed && claimed.some(f => SNIFFABLE.has(f));
+}

package/dist/stream-meter.d.ts

@@ -0,0 +1,39 @@
+/** The limits the xz, lzma and 7z readers check, with their defaults filled in. */
+export interface Limits {
+    entries: number;
+    decompressedBytes: number;
+    totalDecompressedBytes: number;
+    compressionRatio: number;
+    dictionaryBytes: number;
+}
+/** What one decode has produced and the compressed bytes it took, shared by its meters. */
+export interface Totals {
+    decoded: number;
+    compressed: number;
+}
+/** What a reader counts a stream through: the deadline, the compressed bytes it takes and the bytes it decodes. */
+export interface StreamCounter {
+    readonly decoded: number;
+    readonly compressed: number;
+    /** Checks the deadline. */
+    tick(): void;
+    packed(n: number): void;
+    add(n: number): void;
+}
+/** Counts what one stream decodes against the limits, and checks the deadline. */
+export declare class Meter implements StreamCounter {
+    private readonly limits;
+    private readonly totals;
+    private readonly deadline;
+    /** Set for a stream whose size counts against `decompressedBytes`, such as an entry; unset for a solid 7z folder. */
+    private readonly single;
+    private readonly location?;
+    decoded: number;
+    compressed: number;
+    constructor(limits: Limits, totals: Totals, deadline: number | undefined, 
+    /** Set for a stream whose size counts against `decompressedBytes`, such as an entry; unset for a solid 7z folder. */
+    single: boolean, location?: string | undefined);
+    tick(): void;
+    packed(n: number): void;
+    add(n: number): void;
+}

package/dist/stream-meter.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Meter = void 0;
+// Copied from lzma-defuse src/meter.ts when it merged into this package. Changed: the limits come from the engine, and
+// StreamCounter is the shape the xz, lzma and 7z readers count through, so the engine's own meter can stand in.
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+/** The ratio limit applies once a stream has decoded this much, so small files with long runs pass. */
+const RATIO_FLOOR = 1024 * 1024;
+/** Counts what one stream decodes against the limits, and checks the deadline. */
+class Meter {
+    limits;
+    totals;
+    deadline;
+    single;
+    location;
+    decoded = 0;
+    compressed = 0;
+    constructor(limits, totals, deadline, 
+    /** Set for a stream whose size counts against `decompressedBytes`, such as an entry; unset for a solid 7z folder. */
+    single, location) {
+        this.limits = limits;
+        this.totals = totals;
+        this.deadline = deadline;
+        this.single = single;
+        this.location = location;
+    }
+    tick() {
+        (0, errors_1.checkTime)(this.deadline);
+    }
+    packed(n) {
+        this.compressed += n;
+        this.totals.compressed += n;
+    }
+    add(n) {
+        this.decoded += n;
+        this.totals.decoded += n;
+        const loc = this.location;
+        if (this.single && this.decoded > this.limits.decompressedBytes) {
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.DecompressedSize, 'Decompressed size limit exceeded', { limit: this.limits.decompressedBytes }, loc);
+        }
+        if (this.totals.decoded > this.limits.totalDecompressedBytes) {
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.TotalDecompressedSize, 'Total decompressed size limit exceeded', { limit: this.limits.totalDecompressedBytes }, loc);
+        }
+        // The ratio of the whole decode, so one long run of zeros among other files is judged with them, as a solid
+        // folder is.
+        const t = this.totals;
+        if (t.decoded > RATIO_FLOOR && t.decoded > this.limits.compressionRatio * Math.max(1, t.compressed)) {
+            throw new errors_1.StopError(types_1.ArchiveCategory.Limit, types_1.ArchiveDetail.Ratio, 'Compression ratio limit exceeded', { limit: this.limits.compressionRatio }, loc);
+        }
+        (0, errors_1.checkTime)(this.deadline);
+    }
+}
+exports.Meter = Meter;

package/dist/tar.d.ts

@@ -0,0 +1,102 @@
+import { Reader } from './io';
+import type { Archive, Entry, Meter, Note, WriteContext, WritePlan } from './model';
+import { type ByteSink, type ByteSource } from './types';
+export declare const BLOCK = 512;
+/** GNU tar's default record: the archive is padded with zeros to a multiple of it. */
+export declare const RECORD: number;
+/** A pax record kept as written: its key, and its value's bytes. */
+export interface PaxRecord {
+    key: string;
+    value: Buffer;
+}
+export interface TarEntry extends Entry {
+    headerOffset: number;
+    dataOffset: number;
+    /** Bytes of data the archive stores for the entry. For a sparse file, the data segments without the holes. */
+    stored: number;
+    typeflag: string;
+    uid: number;
+    gid: number;
+    uname: string;
+    gname: string;
+    mtime: number;
+    devmajor: number;
+    devminor: number;
+    /** Pax records the rewrite keeps as they are: extended attributes, access and change times, vendor records. */
+    pax: PaxRecord[];
+    /** A sparse file's data segments, as offset and length in the whole file. */
+    sparse?: Array<[number, number]>;
+    /** Bytes at the start of the data that hold a pax 1.0 sparse map. */
+    sparseMapBytes?: number;
+}
+/**
+ * A numeric field: octal digits after any spaces or NULs, up to a space or NUL, or GNU's base-256 with the top bit of
+ * the first byte set. Undefined when the field holds anything else or a value beyond a safe integer.
+ */
+export declare function numeric(b: Uint8Array, at: number, length: number): number | undefined;
+/** Parses pax records, "<length> <key>=<value>\n". Returns them in order, with the reason for any fault that stopped it. */
+export declare function parsePax(data: Uint8Array): {
+    records: PaxRecord[];
+    malformed?: string;
+};
+/** A tar archive read header by header. */
+export declare class TarArchive implements Archive<TarEntry> {
+    readonly reader: Reader;
+    readonly entries: TarEntry[];
+    readonly notes: Note[];
+    /** Where the end-of-archive blocks start, or the archive's data ends. */
+    readonly end: number;
+    /** Where the data after the archive starts. */
+    readonly trailingStart: number;
+    /** The volume label, from a GNU 'V' header. */
+    readonly label?: string | undefined;
+    readonly format = "tar";
+    readonly single = false;
+    readonly lateNotes: Note[];
+    comment?: string;
+    private constructor();
+    static open(source: ByteSource, limits: {
+        entries: number;
+        decompressedBytes: number;
+        totalDecompressedBytes: number;
+    }, deadline?: number): Promise<TarArchive>;
+    /** The offset of the first byte that is not zero, from `from`. */
+    private static firstNonZero;
+    /** True when a tar header sits at a block boundary from `from` on. */
+    private static headerAfter;
+    /** Reads a sparse file's map: GNU's old header and its extensions, or pax 0.0, 0.1 or 1.0. */
+    private static sparse;
+    unlock(): Promise<boolean>;
+    hasMetadata(): boolean;
+    /** The entry's stored data. */
+    raw(e: TarEntry): AsyncGenerator<Uint8Array>;
+    read(e: TarEntry, meter: Meter): AsyncGenerator<Uint8Array>;
+    write(plan: WritePlan<TarEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+    trailing(): AsyncGenerator<Uint8Array>;
+}
+/** One pax record, whose length counts its own digits. */
+export declare function paxRecord(key: string, value: Buffer): Buffer;
+/** A header block. */
+export declare function header(f: {
+    name: Buffer;
+    mode: number;
+    uid: number;
+    gid: number;
+    size: number;
+    mtime: number;
+    typeflag: string;
+    linkname: Buffer;
+    uname: string;
+    gname: string;
+    prefix: Buffer;
+    devmajor: number;
+    devminor: number;
+}): Buffer;
+/** A name in ASCII for the header itself, for readers without pax support. The pax record holds the real one. */
+export declare const asciiFallback: (s: string) => Buffer<ArrayBuffer>;
+/** The name split across the ustar prefix and name fields, or undefined when it does not fit. */
+export declare function split(name: string): {
+    prefix: Buffer;
+    name: Buffer;
+} | undefined;
+export declare const isTar: (head: Uint8Array) => boolean;