@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

package/dist/encoder.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lzma2ChunkWriter = exports.LZMA2_DICT_PROP = exports.LZMA2_DICT_SIZE = exports.RawLzmaEncoder = exports.PROPS_BYTE = exports.PB = exports.LP = exports.LC = void 0;
+exports.fitDictSize = fitDictSize;
+const hc4_1 = require("./lzma1/hc4");
+const lzma_coder_1 = require("./lzma1/lzma-coder");
+const lzma_encoder_fast_1 = require("./lzma1/lzma-encoder-fast");
+const range_encoder_1 = require("./lzma1/range-encoder");
+/** lc, lp and pb of everything this package encodes: lzma1's defaults, and xz's. */
+exports.LC = 3;
+exports.LP = 0;
+exports.PB = 2;
+/** The properties byte of an LZMA header or 7z coder for LC, LP and PB. */
+exports.PROPS_BYTE = (exports.PB * 5 + exports.LP) * 9 + exports.LC;
+/** lzma1's preset 1: the fast encoder with the hash chain match finder and a 1 MiB dictionary. */
+const DICT_SIZE = 1 << 20;
+const NICE_LEN = 128;
+const DEPTH = 8;
+/**
+ * The smallest dictionary that covers `size` bytes, at most 1 MiB and at least 4 KiB, rounded up to 2^n or 2^n +
+ * 2^(n-1) as decoders of the .lzma format expect.
+ */
+function fitDictSize(size) {
+    for (let n = 12; n < 20; ++n) {
+        if (2 ** n >= size)
+            return 2 ** n;
+        if (2 ** n + 2 ** (n - 1) >= size)
+            return 2 ** n + 2 ** (n - 1);
+    }
+    return DICT_SIZE;
+}
+function makeEncoder(rc, dictSize, inputSize) {
+    const lz = new hc4_1.HC4({
+        dictSize,
+        extraSizeBefore: lzma_encoder_fast_1.FAST_EXTRA_SIZE_BEFORE,
+        extraSizeAfter: lzma_encoder_fast_1.FAST_EXTRA_SIZE_AFTER,
+        niceLen: NICE_LEN,
+        matchLenMax: lzma_coder_1.MATCH_LEN_MAX,
+        depthLimit: DEPTH,
+        inputSize,
+    });
+    return new lzma_encoder_fast_1.LzmaEncoderFast(rc, lz, { lc: exports.LC, lp: exports.LP, pb: exports.PB, dictSize, niceLen: NICE_LEN });
+}
+/**
+ * Encodes raw LZMA data of a known size, without an end marker, with lzma1's encoder at its preset 1. The output is
+ * the range coder's bytes, as a 7z LZMA coder and the data of an .lzma file hold them.
+ */
+class RawLzmaEncoder {
+    rc;
+    lzma;
+    dictSize;
+    /** `size` is the input's whole length, or undefined to encode pieces with restart(). */
+    constructor(size, dictSize = size === undefined ? DICT_SIZE : fitDictSize(size)) {
+        this.dictSize = dictSize;
+        this.rc = new range_encoder_1.RangeEncoder(size === undefined ? 1 << 16 : Math.min(size >>> 1, 1 << 20) + 64);
+        this.lzma = makeEncoder(this.rc, dictSize, size);
+    }
+    /** Encodes `input` and returns the bytes ready so far. */
+    write(input) {
+        const lz = this.lzma.lz;
+        for (let off = 0; off < input.length;) {
+            off += lz.fillWindow(input, off, input.length - off);
+            this.lzma.encode();
+        }
+        return this.rc.take();
+    }
+    /** Encodes what is left and returns the last bytes. */
+    finish() {
+        this.lzma.lz.setFinishing();
+        this.lzma.encode();
+        return this.rc.finish();
+    }
+    /** Starts an independent input with the same encoder, whose tables need no new allocation. */
+    restart() {
+        this.rc = new range_encoder_1.RangeEncoder(1 << 16);
+        this.lzma.restart(this.rc);
+    }
+}
+exports.RawLzmaEncoder = RawLzmaEncoder;
+/** The largest data of one LZMA2 chunk, compressed or stored. */
+const CHUNK_MAX = 1 << 16;
+/** Dictionary of the LZMA2 chunks below: every chunk resets it, and no chunk holds more than this. */
+exports.LZMA2_DICT_SIZE = CHUNK_MAX;
+/** The LZMA2 properties byte for LZMA2_DICT_SIZE: (2 | (p & 1)) << (p / 2 + 11) is 64 KiB for 8. */
+exports.LZMA2_DICT_PROP = 8;
+/**
+ * Writes raw LZMA2 data as independent chunks of at most 64 KiB, each compressed by the LZMA1 encoder above, or
+ * stored when that does not make it smaller. Every chunk resets the dictionary and the state, which LZMA2 allows, so
+ * the encoder needs no knowledge of LZMA2. `forceCompressed` keeps a chunk compressed even when that is larger, so the
+ * stored bytes of the content do not show at the start of a file, where other readers look for their own signatures.
+ */
+class Lzma2ChunkWriter {
+    encoder = new RawLzmaEncoder(undefined, exports.LZMA2_DICT_SIZE);
+    used = false;
+    /** The chunks for one piece of at most 64 KiB. With `store`, a piece not forced compressed is stored as it is. */
+    chunk(piece, forceCompressed, store = false) {
+        if (piece.length === 0 || piece.length > CHUNK_MAX)
+            throw new RangeError('An LZMA2 piece must hold 1 to 65536 bytes');
+        const u = piece.length - 1;
+        if (store && !forceCompressed)
+            return Buffer.concat([Uint8Array.of(0x01, (u >>> 8) & 0xff, u & 0xff), piece]);
+        if (this.used)
+            this.encoder.restart();
+        this.used = true;
+        const packed = Buffer.concat([this.encoder.write(piece), this.encoder.finish()]);
+        if (packed.length <= CHUNK_MAX && (packed.length < piece.length || forceCompressed)) {
+            const c = packed.length - 1;
+            const head = Uint8Array.of(0xe0 | (u >>> 16), (u >>> 8) & 0xff, u & 0xff, (c >>> 8) & 0xff, c & 0xff, exports.PROPS_BYTE);
+            return Buffer.concat([head, packed]);
+        }
+        return Buffer.concat([Uint8Array.of(0x01, (u >>> 8) & 0xff, u & 0xff), piece]);
+    }
+}
+exports.Lzma2ChunkWriter = Lzma2ChunkWriter;

package/dist/engine.d.ts

@@ -0,0 +1,44 @@
+import type { Entry, Meter } from './model';
+import { type ArchiveDisarmResult, type ArchiveInspection, type ArchiveOptions, type ByteSink, type ByteSource, type PluginContext } from './types';
+export declare const DEFAULT_LIMITS: {
+    entries: number;
+    decompressedBytes: number;
+    totalDecompressedBytes: number;
+    compressionRatio: number;
+    nestingDepth: number;
+    dictionaryBytes: number;
+};
+/** The key under which archive-defuse hands its run's options to a plugin. No other package can name it. */
+export declare const RUN_OPTIONS: unique symbol;
+/** A plugin context as archive-defuse makes it. */
+export type RunContext = PluginContext & {
+    [RUN_OPTIONS]?: ArchiveOptions;
+};
+/** The passwords to try on an encrypted entry, in order, with the empty password last. */
+export declare const passwordsOf: (options: ArchiveOptions) => string[];
+/** The limits of a run, with the defaults filled in. */
+export declare const limitsOf: (options: ArchiveOptions) => typeof DEFAULT_LIMITS & {
+    fileSize?: number;
+    timeMs?: number;
+};
+/** A meter for one entry: its own decoded size, the run's total, the ratio, and the deadline. */
+export declare function makeMeter(e: Entry, limits: typeof DEFAULT_LIMITS, deadline: number | undefined, totals: {
+    decoded: number;
+}): Meter & {
+    total: number;
+};
+/** Inspects an archive without changing it. The source is closed when the run ends. */
+export declare function inspectArchiveSource(source: ByteSource, options?: ArchiveOptions): Promise<ArchiveInspection>;
+/**
+ * Writes a defused copy of `source` to `sink`. Nothing reaches the sink unless the output passes inspection. The
+ * source is closed when the run ends.
+ */
+export declare function disarmArchiveSource(source: ByteSource, sink: ByteSink, options?: ArchiveOptions): Promise<ArchiveDisarmResult>;
+/** Internal entry that carries the nesting depth for archives inside other files, and the deadline they share with the upload. */
+export declare function disarmAtDepth(source: ByteSource, sink: ByteSink, options: ArchiveOptions, depth: number, deadline?: number | undefined): Promise<ArchiveDisarmResult>;
+/** Inspects archive bytes. */
+export declare function inspectArchive(bytes: Uint8Array, options?: ArchiveOptions): Promise<ArchiveInspection>;
+/** Defuses archive bytes. `bytes` holds the output unless the archive was rejected. */
+export declare function disarmArchive(bytes: Uint8Array, options?: ArchiveOptions): Promise<ArchiveDisarmResult & {
+    bytes?: Uint8Array;
+}>;