@patrickdk77/archive-defuse 0.1.2 → 0.1.3

package/dist/lzma1/range-encoder.js

@@ -1,41 +1,68 @@
 "use strict";
+// Copied from lzma1 0.6.1 (Apache-2.0, Copyright Filip Seman) and changed for archive-defuse. NOTICE in this folder lists the changes.
+/**
+ * Range encoder writing to its own growable buffer.
+ *
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeEncoder.java`
+ * and `RangeEncoderToBuffer.java`, by Lasse Collin and Igor Pavlov.
+ *
+ * Integer adaptations (see the hazard checklist in `docs/verification.md`):
+ * - `low` needs 33 bits (32 bits plus a carry), so it is a regular number;
+ *   doubles represent integers up to 2^53 exactly. The carry test uses
+ *   division instead of `low >>> 32`.
+ * - `range` is an unsigned 32-bit value in a regular number: `<<` is
+ *   followed by `>>> 0`, and `(range & TOP_MASK) == 0` becomes an
+ *   unsigned `range < TOP_VALUE`.
+ * - Bitwise ops on values that may exceed 2^31 are kept off the signed
+ *   int32 path (`low`'s 24-bit wrap multiplies by 256 instead of
+ *   shifting).
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RangeEncoder = void 0;
+exports.createPriceTable = createPriceTable;
 exports.getBitPrice = getBitPrice;
 exports.getBitTreePrice = getBitTreePrice;
 exports.getReverseBitTreePrice = getReverseBitTreePrice;
 exports.getDirectBitsPrice = getDirectBitsPrice;
-// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
 const range_coder_1 = require("./range-coder");
 const MOVE_REDUCING_BITS = 4;
 const BIT_PRICE_SHIFT_BITS = 4;
-/**
- * Price (approximate cost in 1/16 bits) of encoding a bit with a given
- * probability, indexed by `probability >>> MOVE_REDUCING_BITS`.
- */
-const PRICES = createPriceTable();
+// Bit prices in 1/16 bits: the price of a 0 bit, then the same prices
+// reversed, which are the prices of a 1 bit, at
+// (bit << 7) | (prob >>> MOVE_REDUCING_BITS). One lookup without the Java
+// code's bit flip was measured faster.
+const bitPrices = createBitPriceTable();
+function createBitPriceTable() {
+    const prices = createPriceTable();
+    const half = prices.length;
+    const table = new Uint32Array(2 * half);
+    for (let i = 0; i < half; ++i) {
+        table[i] = prices[i];
+        table[half + i] = prices[half - 1 - i];
+    }
+    return table;
+}
 function createPriceTable() {
-    const prices = new Uint32Array(range_coder_1.BIT_MODEL_TOTAL >>> MOVE_REDUCING_BITS);
+    const table = new Uint32Array(range_coder_1.BIT_MODEL_TOTAL >>> MOVE_REDUCING_BITS);
     for (let i = (1 << MOVE_REDUCING_BITS) / 2; i < range_coder_1.BIT_MODEL_TOTAL; i += 1 << MOVE_REDUCING_BITS) {
-        // Approximate -log2(i / BIT_MODEL_TOTAL) using repeated squaring.
         let w = i;
         let bitCount = 0;
         for (let j = 0; j < BIT_PRICE_SHIFT_BITS; ++j) {
             w *= w;
             bitCount <<= 1;
-            while (w >= 0x10000) {
+            while ((w & 0xffff0000) !== 0) {
                 w >>>= 1;
                 ++bitCount;
             }
         }
-        prices[i >> MOVE_REDUCING_BITS] = (range_coder_1.BIT_MODEL_TOTAL_BITS << BIT_PRICE_SHIFT_BITS) - 15 - bitCount;
+        table[i >> MOVE_REDUCING_BITS] = (range_coder_1.BIT_MODEL_TOTAL_BITS << BIT_PRICE_SHIFT_BITS) - 15 - bitCount;
     }
-    return prices;
+    return table;
 }
 function getBitPrice(prob, bit) {
-    return PRICES[(prob ^ (-bit & (range_coder_1.BIT_MODEL_TOTAL - 1))) >>> MOVE_REDUCING_BITS];
+    // NOTE: Unlike in encodeBit(), here bit must be 0 or 1.
+    return bitPrices[(bit << 7) | (prob >>> MOVE_REDUCING_BITS)];
 }
-/** Price of a `bits`-bit symbol coded MSB-first with the bit tree at `offset`. */
 function getBitTreePrice(probs, offset, bits, symbolIn) {
     let symbol = symbolIn;
     let price = 0;
@@ -47,42 +74,47 @@ function getBitTreePrice(probs, offset, bits, symbolIn) {
     } while (symbol !== 1);
     return price;
 }
-/** Price of a `bits`-bit symbol coded LSB-first with the bit tree at `offset`. */
 function getReverseBitTreePrice(probs, offset, bits, symbolIn) {
     let symbol = symbolIn;
     let price = 0;
     let index = 1;
-    for (let i = 0; i < bits; ++i) {
+    symbol |= 1 << bits;
+    do {
         const bit = symbol & 1;
         symbol >>>= 1;
         price += getBitPrice(probs[offset + index], bit);
         index = (index << 1) | bit;
-    }
+    } while (symbol !== 1);
     return price;
 }
-/** Price of bits coded with a fixed 50% probability. */
 function getDirectBitsPrice(count) {
     return count << BIT_PRICE_SHIFT_BITS;
 }
-/**
- * Range encoder writing to its own growable buffer.
- *
- * `low` needs 33 bits (32 bits plus a carry), so it is kept as a regular
- * number instead of an int32. Doubles represent integers up to 2^53 exactly.
- *
- * Performance: like `RangeDecoder`, the methods that encode several bits
- * keep `range` and `low` in local variables for the whole symbol.
- */
 class RangeEncoder {
     low = 0;
     range = 0xffffffff;
     cache = 0;
+    /**
+     * NOTE: int is OK for LZMA2 because a compressed chunk is not more
+     * than 64 KiB, but with LZMA1 there is no chunking so in theory
+     * cacheSize can grow very big. A JS number counts well past 2^32.
+     */
     cacheSize = 1;
+    // Instead of the fixed output array of RangeEncoderToBuffer, the
+    // buffer grows on demand and the written bytes are handed out with
+    // take()/finish(), because the compressed size isn't known in advance
+    // here (contract adaptation).
     buf;
     size = 0;
     constructor(initialCapacity) {
         this.buf = new Uint8Array(Math.max(64, initialCapacity));
     }
+    reset() {
+        this.low = 0;
+        this.range = 0xffffffff;
+        this.cache = 0x00;
+        this.cacheSize = 1;
+    }
     /** Appends bytes that are not range coded, e.g. a header. */
     writeBytes(bytes) {
         this.ensureCapacity(bytes.length);
@@ -97,16 +129,34 @@ class RangeEncoder {
     }
     /** Flushes all pending bytes and returns the rest of the output. */
     finish() {
-        let low = this.low;
         for (let i = 0; i < 5; ++i) {
-            low = this.shiftLow(low);
+            this.shiftLow();
         }
-        this.low = low;
         return this.size === this.buf.length ? this.buf : this.buf.slice(0, this.size);
     }
+    writeByte(b) {
+        this.ensureCapacity(1);
+        this.buf[this.size++] = b;
+    }
+    shiftLow() {
+        // (int)(low >>> 32), the pending carry: 0 or 1.
+        const lowHi = Math.floor(this.low / 0x100000000);
+        if (lowHi !== 0 || this.low < 0xff000000) {
+            let temp = this.cache;
+            do {
+                this.writeByte(temp + lowHi);
+                temp = 0xff;
+            } while (--this.cacheSize !== 0);
+            this.cache = (this.low >>> 24) & 0xff;
+        }
+        ++this.cacheSize;
+        // (low & 0x00FFFFFF) << 8, kept exact above 2^31 with * 256.
+        this.low = (this.low & 0x00ffffff) * 256;
+    }
     encodeBit(probs, index, bit) {
         const prob = probs[index];
         const bound = (this.range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+        // NOTE: Any non-zero value for bit is taken as 1.
         if (bit === 0) {
             this.range = bound;
             probs[index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
@@ -118,145 +168,43 @@ class RangeEncoder {
         }
         if (this.range < range_coder_1.TOP_VALUE) {
             this.range = (this.range << 8) >>> 0;
-            this.low = this.shiftLow(this.low);
+            this.shiftLow();
         }
     }
-    /** Encodes a `bits`-bit symbol MSB-first with the bit tree at `offset`. */
     encodeBitTree(probs, offset, bits, symbol) {
-        let range = this.range;
-        let low = this.low;
         let index = 1;
-        for (let i = bits - 1; i >= 0; --i) {
-            const bit = (symbol >>> i) & 1;
-            const prob = probs[offset + index];
-            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (bit === 0) {
-                range = bound;
-                probs[offset + index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-            }
-            else {
-                low += bound;
-                range -= bound;
-                probs[offset + index] = prob - (prob >>> range_coder_1.MOVE_BITS);
-            }
-            if (range < range_coder_1.TOP_VALUE) {
-                range = (range << 8) >>> 0;
-                low = this.shiftLow(low);
+        let mask = 1 << bits;
+        do {
+            mask >>>= 1;
+            const bit = symbol & mask;
+            this.encodeBit(probs, offset + index, bit);
+            index <<= 1;
+            if (bit !== 0) {
+                index |= 1;
             }
-            index = (index << 1) | bit;
-        }
-        this.range = range;
-        this.low = low;
+        } while (mask !== 1);
     }
-    /** Encodes a `bits`-bit symbol LSB-first with the bit tree at `offset`. */
     encodeReverseBitTree(probs, offset, bits, symbolIn) {
         let symbol = symbolIn;
-        let range = this.range;
-        let low = this.low;
         let index = 1;
-        for (let i = 0; i < bits; ++i) {
+        symbol |= 1 << bits;
+        do {
             const bit = symbol & 1;
             symbol >>>= 1;
-            const prob = probs[offset + index];
-            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (bit === 0) {
-                range = bound;
-                probs[offset + index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-            }
-            else {
-                low += bound;
-                range -= bound;
-                probs[offset + index] = prob - (prob >>> range_coder_1.MOVE_BITS);
-            }
-            if (range < range_coder_1.TOP_VALUE) {
-                range = (range << 8) >>> 0;
-                low = this.shiftLow(low);
-            }
+            this.encodeBit(probs, offset + index, bit);
             index = (index << 1) | bit;
-        }
-        this.range = range;
-        this.low = low;
-    }
-    /** Encodes a literal byte with the 0x100-leaf bit tree at `offset`. */
-    encodeLiteral(probs, offset, symbol) {
-        this.encodeBitTree(probs, offset, 8, symbol);
+        } while (symbol !== 1);
     }
-    /**
-     * Encodes a literal after a match. The bits of `matchByte` (the byte at
-     * rep0) select separate probabilities until the first bit that differs.
-     */
-    encodeMatchedLiteral(probs, offset, symbolIn, matchByteIn) {
-        let symbol = symbolIn;
-        let matchByte = matchByteIn;
-        let range = this.range;
-        let low = this.low;
-        let matchOffset = 0x100;
-        symbol |= 0x100;
-        do {
-            matchByte <<= 1;
-            const matchBit = matchByte & matchOffset;
-            const index = offset + matchOffset + matchBit + (symbol >>> 8);
-            const bit = (symbol >>> 7) & 1;
-            const prob = probs[index];
-            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (bit === 0) {
-                range = bound;
-                probs[index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-            }
-            else {
-                low += bound;
-                range -= bound;
-                probs[index] = prob - (prob >>> range_coder_1.MOVE_BITS);
-            }
-            if (range < range_coder_1.TOP_VALUE) {
-                range = (range << 8) >>> 0;
-                low = this.shiftLow(low);
-            }
-            symbol <<= 1;
-            matchOffset &= ~(matchByte ^ symbol);
-        } while (symbol < 0x10000);
-        this.range = range;
-        this.low = low;
-    }
-    /** Encodes the `count` low bits of `value` with a fixed 50% probability. */
     encodeDirectBits(value, countIn) {
         let count = countIn;
-        let range = this.range;
-        let low = this.low;
         do {
-            range >>>= 1;
-            if (((value >>> --count) & 1) !== 0) {
-                low += range;
-            }
-            if (range < range_coder_1.TOP_VALUE) {
-                range = (range << 8) >>> 0;
-                low = this.shiftLow(low);
+            this.range >>>= 1;
+            this.low += this.range & (0 - ((value >>> --count) & 1));
+            if (this.range < range_coder_1.TOP_VALUE) {
+                this.range = (this.range << 8) >>> 0;
+                this.shiftLow();
             }
         } while (count !== 0);
-        this.range = range;
-        this.low = low;
-    }
-    /**
-     * Moves the top byte of `low` to the output and returns the new `low`.
-     * A run of 0xFF bytes is held back (`cache` + `cacheSize`) until it is
-     * known whether a carry will propagate into it.
-     */
-    shiftLow(low) {
-        if (low < 0xff000000 || low >= 0x100000000) {
-            const carry = low >= 0x100000000 ? 1 : 0;
-            this.ensureCapacity(this.cacheSize);
-            const buf = this.buf;
-            let size = this.size;
-            buf[size++] = (this.cache + carry) & 0xff;
-            for (let i = 1; i < this.cacheSize; ++i) {
-                buf[size++] = (0xff + carry) & 0xff;
-            }
-            this.size = size;
-            this.cacheSize = 0;
-            this.cache = (low >>> 24) & 0xff;
-        }
-        ++this.cacheSize;
-        return (low & 0x00ffffff) * 256;
     }
     ensureCapacity(extra) {
         if (this.size + extra > this.buf.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patrickdk77/archive-defuse",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Sanitize zip, tar, gzip, bzip2, zstd, Brotli, cab, 7z, xz and lzma archives. Detects path traversal, links out of the tree, device files, duplicate names, overlapping entries, hidden and prepended data, encrypted entries and compression bombs, hands every entry to file plugins, scores the risk, and writes a defused archive in the same format with no runtime dependencies.",
   "license": "MIT AND Apache-2.0",
   "author": "patrickdk77",