@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/zip-writer.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipOutput = exports.METADATA_EXTRAS = void 0;
+exports.writeZip = writeZip;
+// Copied from office-defuse src/zip-writer.ts. Changed: an entry keeps its method, times, permissions, comment and the
+// extra fields the plan keeps, and either copies its compressed bytes without their encryption or is compressed again
+// from the content the plan gives. Data the plan keeps before and after the archive is written around it.
+const codecs_1 = require("./codecs");
+const crc32_1 = require("./crc32");
+const io_1 = require("./io");
+const model_1 = require("./model");
+/** Extra field records that hold only times and owners. The rewrite keeps them unless metadata is stripped. */
+exports.METADATA_EXTRAS = new Set([0x5455, 0x000a, 0x7875, 0x5855, 0x7855]);
+const MAX16 = 0xffff;
+const MAX32 = 0xffffffff;
+/** 1980-01-01 00:00, the earliest date a ZIP header holds, for entries whose times are stripped. */
+const DOS_DATE = (0 << 9) | (1 << 5) | 1;
+/** Unix file type bits, for the attributes of an entry that has permissions. */
+const TYPE_BITS = { file: 0o100000, directory: 0o040000, symlink: 0o120000 };
+class Builder {
+    parts = [];
+    u16(v) {
+        this.parts.push(v & 0xff, (v >>> 8) & 0xff);
+        return this;
+    }
+    u32(v) {
+        return this.u16(v & 0xffff).u16(Math.floor(v / 0x10000) & 0xffff);
+    }
+    u64(v) {
+        return this.u32(v % 0x100000000).u32(Math.floor(v / 0x100000000));
+    }
+    bytes(b) {
+        for (const x of b)
+            this.parts.push(x);
+        return this;
+    }
+    build() {
+        return Uint8Array.from(this.parts);
+    }
+}
+const versionFor = (method) => (method === 93 || method === 14 || method === 95 ? 63 : method === 12 ? 46 : method === 9 ? 21 : 20);
+/**
+ * Writes the entries of a ZIP archive one after another, then its central directory. Local headers carry the CRC and
+ * sizes, so no entry needs a data descriptor. ZIP64 records appear only where a size, an offset or the entry count
+ * needs them.
+ */
+class ZipOutput {
+    sink;
+    offset = 0;
+    central = [];
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** Writes bytes as they are, such as data kept before the archive. */
+    async put(b) {
+        await this.sink.write(b);
+        this.offset += b.length;
+    }
+    /** Writes one entry: its local header, then `chunks`, which must hold exactly `info.compressedSize` bytes. */
+    async entry(info, chunks, label) {
+        const big = info.size >= MAX32 || info.compressedSize >= MAX32;
+        const localOffset = this.offset;
+        const local = new Builder()
+            .u32(0x04034b50)
+            .u16(big ? Math.max(45, info.versionNeeded) : info.versionNeeded)
+            .u16(info.flags)
+            .u16(info.method)
+            .u16(info.time)
+            .u16(info.date)
+            .u32(info.crc)
+            .u32(big ? MAX32 : info.compressedSize)
+            .u32(big ? MAX32 : info.size)
+            .u16(info.name.length)
+            .u16(info.extras.length + (big ? 20 : 0))
+            .bytes(info.name);
+        if (big)
+            local.u16(0x0001).u16(16).u64(info.size).u64(info.compressedSize);
+        local.bytes(info.extras);
+        await this.put(local.build());
+        let written = 0;
+        for await (const c of chunks()) {
+            written += c.length;
+            await this.put(c);
+        }
+        if (written !== info.compressedSize)
+            throw new Error(`Entry ${label} has ${written} compressed bytes, not ${info.compressedSize}`);
+        const far = localOffset >= MAX32;
+        const z64 = new Builder();
+        if (info.size >= MAX32)
+            z64.u64(info.size);
+        if (info.compressedSize >= MAX32)
+            z64.u64(info.compressedSize);
+        if (far)
+            z64.u64(localOffset);
+        const z64Bytes = z64.build();
+        const needed = z64Bytes.length ? Math.max(45, info.versionNeeded) : info.versionNeeded;
+        const c = new Builder()
+            .u32(0x02014b50)
+            .u16(info.versionMadeBy)
+            .u16(needed)
+            .u16(info.flags)
+            .u16(info.method)
+            .u16(info.time)
+            .u16(info.date)
+            .u32(info.crc)
+            .u32(info.compressedSize >= MAX32 ? MAX32 : info.compressedSize)
+            .u32(info.size >= MAX32 ? MAX32 : info.size)
+            .u16(info.name.length)
+            .u16(info.extras.length + (z64Bytes.length ? z64Bytes.length + 4 : 0))
+            .u16(info.comment.length)
+            .u16(0)
+            .u16(info.internalAttr)
+            .u32(info.externalAttr)
+            .u32(far ? MAX32 : localOffset)
+            .bytes(info.name);
+        if (z64Bytes.length)
+            c.u16(0x0001).u16(z64Bytes.length).bytes(z64Bytes);
+        c.bytes(info.extras).bytes(info.comment);
+        this.central.push(c.build());
+    }
+    /** Writes the central directory and the end records, with the archive's comment. */
+    async end(comment) {
+        const dirOffset = this.offset;
+        for (const c of this.central)
+            await this.put(c);
+        const dirSize = this.offset - dirOffset;
+        const count = this.central.length;
+        const big = count >= MAX16 || dirOffset >= MAX32 || dirSize >= MAX32;
+        if (big) {
+            const end64 = this.offset;
+            await this.put(new Builder().u32(0x06064b50).u64(44).u16(45).u16(45).u32(0).u32(0).u64(count).u64(count).u64(dirSize).u64(dirOffset).build());
+            await this.put(new Builder().u32(0x07064b50).u32(0).u64(end64).u32(1).build());
+        }
+        await this.put(new Builder()
+            .u32(0x06054b50)
+            .u16(0)
+            .u16(0)
+            .u16(big ? MAX16 : count)
+            .u16(big ? MAX16 : count)
+            .u32(big ? MAX32 : dirSize)
+            .u32(big ? MAX32 : dirOffset)
+            .u16(comment.length)
+            .bytes(comment)
+            .build());
+    }
+}
+exports.ZipOutput = ZipOutput;
+/** Writes `zip` again with the entries `plan` keeps. */
+async function writeZip(zip, plan, sink, context) {
+    const out = new ZipOutput(sink);
+    if (plan.keepLeading)
+        for await (const c of zip.leading())
+            await out.put(c);
+    for (const k of plan.kept) {
+        context.meter().time();
+        const p = await prepare(zip, k, plan, context);
+        try {
+            await out.entry(p.info, p.chunks, k.name);
+        }
+        finally {
+            await p.spill?.dispose();
+        }
+    }
+    await out.end(plan.stripMetadata ? new Uint8Array(0) : zip.commentBytes);
+    if (plan.keepTrailing)
+        for await (const c of zip.trailing())
+            await out.put(c);
+}
+/**
+ * An extended timestamp record with its flags naming only the times it holds. The rewrite writes the central
+ * directory's record, which may hold the modification time alone, into the local header too, where the flags have to
+ * match the times that follow.
+ */
+function timestampFlags(data) {
+    let count = (data.length - 1) / 4;
+    let flags = 0;
+    for (let bit = 1; bit <= 4 && count > 0; bit <<= 1) {
+        if (data[0] & bit) {
+            flags |= bit;
+            count--;
+        }
+    }
+    if (flags === data[0])
+        return data;
+    const out = Uint8Array.from(data);
+    out[0] = flags;
+    return out;
+}
+/** The headers and data of one kept entry: its own compressed bytes without their encryption, or its content compressed again. */
+async function prepare(zip, k, plan, context) {
+    const e = k.entry;
+    const isDir = e.kind === 'directory';
+    const name = Buffer.from(isDir && !k.name.endsWith('/') ? `${k.name}/` : k.name, 'utf8');
+    const comment = plan.stripMetadata || !e.comment ? Buffer.alloc(0) : Buffer.from(e.comment, 'utf8');
+    const flags = /^[\x20-\x7e]*$/.test(k.name) && /^[\x20-\x7e]*$/.test(e.comment && !plan.stripMetadata ? e.comment : '') ? 0 : 0x0800;
+    const extras = Buffer.concat(e.extras
+        .filter(r => (exports.METADATA_EXTRAS.has(r.id) ? !plan.stripMetadata && (!r.malformed || plan.keepExtraFields) : plan.keepExtraFields))
+        .map(r => new Builder()
+        .u16(r.id)
+        .u16(r.data.length)
+        .bytes(r.id === 0x5455 && !r.malformed ? timestampFlags(r.data) : r.data)
+        .build()));
+    const unix = k.mode !== undefined;
+    const typeBits = TYPE_BITS[e.kind] ?? 0;
+    const info = {
+        name,
+        flags,
+        method: 0,
+        versionNeeded: 20,
+        versionMadeBy: unix ? (3 << 8) | 30 : 20,
+        externalAttr: unix ? (((typeBits | (k.mode ?? 0)) << 16) >>> 0) | (isDir ? 0x10 : 0) : (e.externalAttr & 0xff & ~0x10) | (isDir ? 0x10 : 0),
+        internalAttr: e.internalAttr,
+        time: plan.stripMetadata ? 0 : e.dosTime,
+        date: plan.stripMetadata ? DOS_DATE : e.dosDate,
+        crc: 0,
+        compressedSize: 0,
+        size: 0,
+        extras,
+        comment,
+    };
+    if (isDir)
+        return { info, chunks: model_1.nothing };
+    if (!k.replacement && !k.recompress) {
+        // The compressed bytes are copied, without any encryption they had.
+        info.method = e.methodCode;
+        info.versionNeeded = versionFor(e.methodCode);
+        info.crc = k.crc ?? e.crc;
+        info.size = e.size;
+        info.compressedSize = zip.plainLength(e);
+        return { info, chunks: () => zip.plain(e, k.password) };
+    }
+    // Compressed again: deflate, or stored when deflate gains nothing or would pass the run's ratio limit.
+    const size = (0, model_1.sizeOf)(k);
+    let crc = 0;
+    async function* withCrc(chunks) {
+        for await (const c of chunks) {
+            context.meter().time();
+            crc = (0, crc32_1.crc32)(c, crc);
+            yield c;
+        }
+    }
+    const spill = new io_1.SpillSink(context.temp, context.threshold);
+    try {
+        for await (const c of (0, codecs_1.deflateRaw)(withCrc((0, model_1.contentOf)(zip, k, context))))
+            await spill.write(c);
+        await spill.close();
+    }
+    catch (err) {
+        await spill.dispose();
+        throw err;
+    }
+    info.crc = crc;
+    info.size = size;
+    const passesRatio = size <= 1024 * 1024 || size <= spill.length * plan.ratioLimit;
+    if (size > 0 && spill.length < size && passesRatio) {
+        info.method = 8;
+        info.compressedSize = spill.length;
+        return { info, chunks: () => spill.read(), spill };
+    }
+    await spill.dispose();
+    info.compressedSize = size;
+    return { info, chunks: () => (0, model_1.contentOf)(zip, k, context) };
+}

package/dist/zip.d.ts

@@ -0,0 +1,99 @@
+import type { TempDir } from './io';
+import type { Limits } from './stream-meter';
+import { Reader } from './io';
+import type { Archive, Entry, Meter, Note, WriteContext, WritePlan } from './model';
+import { type ByteSink, type ByteSource } from './types';
+export interface ZipLimits {
+    entries: number;
+    decompressedBytes: number;
+    totalDecompressedBytes: number;
+    compressionRatio: number;
+}
+/** One record of an extra field. */
+export interface ExtraRecord {
+    id: number;
+    data: Uint8Array;
+    /** A times or owners record that does not have its documented layout. */
+    malformed?: boolean;
+}
+export interface ZipEntry extends Entry {
+    rawName: Uint8Array;
+    flags: number;
+    /** The method field of the headers: 99 for AES. */
+    storedMethod: number;
+    /** The method the data is compressed with, inside any encryption. */
+    methodCode: number;
+    versionMadeBy: number;
+    externalAttr: number;
+    internalAttr: number;
+    dosTime: number;
+    dosDate: number;
+    crc: number;
+    localOffset: number;
+    dataOffset: number;
+    /** Where the entry ends, after any data descriptor. */
+    end: number;
+    /** Central directory extra records, apart from the ones the rewrite replaces. */
+    extras: ExtraRecord[];
+    /** The entry's comment as stored. */
+    commentBytes: Uint8Array;
+    /** WinZip AES: 1 for AE-1, which keeps the CRC, 2 for AE-2, which does not. */
+    aesVersion?: number;
+    aesStrength?: number;
+}
+/**
+ * A ZIP archive read from its central directory, with every local header checked against it. Reading an entry
+ * decrypts and decodes it in chunks and checks its size and CRC.
+ */
+export declare class ZipArchive implements Archive<ZipEntry> {
+    readonly reader: Reader;
+    readonly entries: ZipEntry[];
+    readonly notes: Note[];
+    /** Where the archive starts in the file: the first local header, or the directory when there is none. */
+    readonly start: number;
+    /** Where the archive ends: after the end record's comment. */
+    readonly end: number;
+    readonly commentBytes: Uint8Array;
+    /** Where the other end records that lead to a directory sit, which an entry's data can hold. */
+    readonly rivals: number[];
+    readonly format = "zip";
+    readonly single = false;
+    readonly lateNotes: Note[];
+    comment?: string;
+    private constructor();
+    /** What LZMA and XZ entries need from the run: its limits, and a temporary folder for an XZ entry's bytes. */
+    decoders?: {
+        temp: TempDir;
+        threshold: number;
+        limits: Limits;
+    };
+    static open(source: ByteSource, limits: ZipLimits, deadline?: number): Promise<ZipArchive>;
+    /** One entry from its central directory header. */
+    private static central;
+    /** The encryption an entry uses, from its flags and its AES field, which also gives the method inside. */
+    private static encryption;
+    /** Checks a local header and any data descriptor against the central directory, and fills in where the entry's data and the entry end. */
+    private static checkLocal;
+    /** Bytes before the first entry, bytes between entries and the directory that belong to none, and entries that share bytes. */
+    private static coverage;
+    hasMetadata(): boolean;
+    /** Reads a symbolic link's target, which a ZIP stores as the entry's content. */
+    linkTarget(e: ZipEntry, meter: Meter): Promise<string | undefined>;
+    /** The stored bytes of an entry. */
+    raw(e: ZipEntry): AsyncGenerator<Uint8Array>;
+    /** The bytes before the archive and after it. */
+    leading(): AsyncGenerator<Uint8Array>;
+    trailing(): AsyncGenerator<Uint8Array>;
+    /** The 12-byte ZipCrypto header's check byte: the CRC's high byte, or the time's with a data descriptor. */
+    private checkByte;
+    unlock(e: ZipEntry, password: string): Promise<boolean>;
+    /** The entry's compressed bytes without their encryption, for a rewrite that copies them. Their length comes from `plainLength`. */
+    plain(e: ZipEntry, password?: string): AsyncGenerator<Uint8Array>;
+    /** The length of what plain() yields. */
+    plainLength(e: ZipEntry): number;
+    /** The entry's content in chunks. Its size, its CRC unless AE-2 leaves it out, and the compressed bytes used must all agree with the central directory. */
+    read(e: ZipEntry, meter: Meter, password?: string): AsyncGenerator<Uint8Array>;
+    write(plan: WritePlan<ZipEntry>, sink: ByteSink, context: WriteContext): Promise<void>;
+}
+/** True when the file ends in what may be a ZIP archive: an end record signature in the last 64 KiB. */
+export declare function hasZipEnd(source: ByteSource): Promise<boolean>;