@zklogic/unzipper 0.13.0

package/lib/parse.js

@@ -0,0 +1,288 @@
+const util = require('util');
+const zlib = require('zlib');
+const Stream = require('stream');
+const PullStream = require('./PullStream');
+const NoopStream = require('./NoopStream');
+const BufferStream = require('./BufferStream');
+const parseExtraField = require('./parseExtraField');
+const parseDateTime = require('./parseDateTime');
+const pipeline = Stream.pipeline;
+const parseBuffer = require('./parseBuffer');
+
+const endDirectorySignature = Buffer.alloc(4);
+endDirectorySignature.writeUInt32LE(0x06054b50, 0);
+
+function Parse(opts) {
+  if (!(this instanceof Parse)) {
+    return new Parse(opts);
+  }
+  const self = this;
+  self._opts = opts || { verbose: false };
+
+  PullStream.call(self, self._opts);
+  self.on('finish', function() {
+    self.emit('end');
+    self.emit('close');
+  });
+  self._readRecord().catch(function(e) {
+    if (!self.__emittedError || self.__emittedError !== e)
+      self.emit('error', e);
+  });
+}
+
+util.inherits(Parse, PullStream);
+
+Parse.prototype._readRecord = function () {
+  const self = this;
+
+  return self.pull(4).then(function(data) {
+    if (data.length === 0)
+      return;
+
+    const signature = data.readUInt32LE(0);
+
+    if (signature === 0x34327243) {
+      return self._readCrxHeader();
+    }
+    if (signature === 0x04034b50) {
+      return self._readFile();
+    }
+    else if (signature === 0x02014b50) {
+      self.reachedCD = true;
+      return self._readCentralDirectoryFileHeader();
+    }
+    else if (signature === 0x06054b50) {
+      return self._readEndOfCentralDirectoryRecord();
+    }
+    else if (self.reachedCD) {
+      // _readEndOfCentralDirectoryRecord expects the EOCD
+      // signature to be consumed so set includeEof=true
+      const includeEof = true;
+      return self.pull(endDirectorySignature, includeEof).then(function() {
+        return self._readEndOfCentralDirectoryRecord();
+      });
+    }
+    else
+      self.emit('error', new Error('invalid signature: 0x' + signature.toString(16)));
+  }).then((function(loop) {
+    if(loop) {
+      return self._readRecord();
+    }
+  }));
+};
+
+Parse.prototype._readCrxHeader = function() {
+  const self = this;
+  return self.pull(12).then(function(data) {
+    self.crxHeader = parseBuffer.parse(data, [
+      ['version', 4],
+      ['pubKeyLength', 4],
+      ['signatureLength', 4],
+    ]);
+    return self.pull(self.crxHeader.pubKeyLength + self.crxHeader.signatureLength);
+  }).then(function(data) {
+    self.crxHeader.publicKey = data.slice(0, self.crxHeader.pubKeyLength);
+    self.crxHeader.signature = data.slice(self.crxHeader.pubKeyLength);
+    self.emit('crx-header', self.crxHeader);
+    return true;
+  });
+};
+
+Parse.prototype._readFile = function () {
+  const self = this;
+  return self.pull(26).then(function(data) {
+    const vars = parseBuffer.parse(data, [
+      ['versionsNeededToExtract', 2],
+      ['flags', 2],
+      ['compressionMethod', 2],
+      ['lastModifiedTime', 2],
+      ['lastModifiedDate', 2],
+      ['crc32', 4],
+      ['compressedSize', 4],
+      ['uncompressedSize', 4],
+      ['fileNameLength', 2],
+      ['extraFieldLength', 2],
+    ]);
+
+    vars.lastModifiedDateTime = parseDateTime(vars.lastModifiedDate, vars.lastModifiedTime);
+
+    if (self.crxHeader) vars.crxHeader = self.crxHeader;
+
+    return self.pull(vars.fileNameLength).then(function(fileNameBuffer) {
+      const fileName = fileNameBuffer.toString('utf8');
+      const entry = Stream.PassThrough();
+      let __autodraining = false;
+
+      entry.autodrain = function() {
+        __autodraining = true;
+        const draining = entry.pipe(NoopStream());
+        draining.promise = function() {
+          return new Promise(function(resolve, reject) {
+            draining.on('finish', resolve);
+            draining.on('error', reject);
+          });
+        };
+        return draining;
+      };
+
+      entry.buffer = function() {
+        return BufferStream(entry);
+      };
+
+      entry.path = fileName;
+      entry.props = {};
+      entry.props.path = fileName;
+      entry.props.pathBuffer = fileNameBuffer;
+      entry.props.flags = {
+        "isUnicode": (vars.flags & 0x800) != 0
+      };
+      entry.type = (vars.uncompressedSize === 0 && /[/\\]$/.test(fileName)) ? 'Directory' : 'File';
+
+      if (self._opts.verbose) {
+        if (entry.type === 'Directory') {
+          console.log('   creating:', fileName);
+        } else if (entry.type === 'File') {
+          if (vars.compressionMethod === 0) {
+            console.log(' extracting:', fileName);
+          } else {
+            console.log('  inflating:', fileName);
+          }
+        }
+      }
+
+      return self.pull(vars.extraFieldLength).then(function(extraField) {
+        const extra = parseExtraField(extraField, vars);
+
+        entry.vars = vars;
+        entry.extra = extra;
+
+        if (self._opts.forceStream) {
+          self.push(entry);
+        } else {
+          self.emit('entry', entry);
+
+          if (self._readableState.pipesCount || (self._readableState.pipes && self._readableState.pipes.length))
+            self.push(entry);
+        }
+
+        if (self._opts.verbose)
+          console.log({
+            filename:fileName,
+            vars: vars,
+            extra: extra
+          });
+
+        const fileSizeKnown = !(vars.flags & 0x08) || vars.compressedSize > 0;
+        let eof;
+
+        entry.__autodraining = __autodraining; // expose __autodraining for test purposes
+        const inflater = (vars.compressionMethod && !__autodraining) ? zlib.createInflateRaw() : Stream.PassThrough();
+
+        if (fileSizeKnown) {
+          entry.size = vars.uncompressedSize;
+          eof = vars.compressedSize;
+        } else {
+          eof = Buffer.alloc(4);
+          eof.writeUInt32LE(0x08074b50, 0);
+        }
+
+        return new Promise(function(resolve, reject) {
+          pipeline(
+            self.stream(eof),
+            inflater,
+            entry,
+            function (err) {
+              if (err) {
+                return reject(err);
+              }
+
+              return fileSizeKnown ? resolve(fileSizeKnown) : self._processDataDescriptor(entry).then(resolve).catch(reject);
+            }
+          );
+        });
+      });
+    });
+  });
+};
+
+Parse.prototype._processDataDescriptor = function (entry) {
+  const self = this;
+  return self.pull(16).then(function(data) {
+    const vars = parseBuffer.parse(data, [
+      ['dataDescriptorSignature', 4],
+      ['crc32', 4],
+      ['compressedSize', 4],
+      ['uncompressedSize', 4],
+    ]);
+
+    entry.size = vars.uncompressedSize;
+    return true;
+  });
+};
+
+Parse.prototype._readCentralDirectoryFileHeader = function () {
+  const self = this;
+  return self.pull(42).then(function(data) {
+    const vars = parseBuffer.parse(data, [
+      ['versionMadeBy', 2],
+      ['versionsNeededToExtract', 2],
+      ['flags', 2],
+      ['compressionMethod', 2],
+      ['lastModifiedTime', 2],
+      ['lastModifiedDate', 2],
+      ['crc32', 4],
+      ['compressedSize', 4],
+      ['uncompressedSize', 4],
+      ['fileNameLength', 2],
+      ['extraFieldLength', 2],
+      ['fileCommentLength', 2],
+      ['diskNumber', 2],
+      ['internalFileAttributes', 2],
+      ['externalFileAttributes', 4],
+      ['offsetToLocalFileHeader', 4],
+    ]);
+
+    return self.pull(vars.fileNameLength).then(function(fileName) {
+      vars.fileName = fileName.toString('utf8');
+      return self.pull(vars.extraFieldLength);
+    })
+      .then(function() {
+        return self.pull(vars.fileCommentLength);
+      })
+      .then(function() {
+        return true;
+      });
+  });
+};
+
+Parse.prototype._readEndOfCentralDirectoryRecord = function() {
+  const self = this;
+  return self.pull(18).then(function(data) {
+
+    const vars = parseBuffer.parse(data, [
+      ['diskNumber', 2],
+      ['diskStart', 2],
+      ['numberOfRecordsOnDisk', 2],
+      ['numberOfRecords', 2],
+      ['sizeOfCentralDirectory', 4],
+      ['offsetToStartOfCentralDirectory', 4],
+      ['commentLength', 2],
+    ]);
+
+    return self.pull(vars.commentLength).then(function() {
+      self.end();
+      self.push(null);
+    });
+
+  });
+};
+
+Parse.prototype.promise = function() {
+  const self = this;
+  return new Promise(function(resolve, reject) {
+    self.on('finish', resolve);
+    self.on('error', reject);
+  });
+};
+
+module.exports = Parse;

package/lib/parseBuffer.js

@@ -0,0 +1,55 @@
+const parseUIntLE = function(buffer, offset, size) {
+  let result;
+  switch(size) {
+    case 1:
+      result = buffer.readUInt8(offset);
+      break;
+    case 2:
+      result = buffer.readUInt16LE(offset);
+      break;
+    case 4:
+      result = buffer.readUInt32LE(offset);
+      break;
+    case 8:
+      result = Number(buffer.readBigUInt64LE(offset));
+      break;
+    default:
+      throw new Error('Unsupported UInt LE size!');
+  }
+  return result;
+};
+
+/**
+ * Parses sequential unsigned little endian numbers from the head of the passed buffer according to
+ * the specified format passed.  If the buffer is not large enough to satisfy the full format,
+ * null values will be assigned to the remaining keys.
+ * @param {*} buffer The buffer to sequentially extract numbers from.
+ * @param {*} format Expected format to follow when extrcting values from the buffer.  A list of list entries
+ * with the following structure:
+ * [
+ *   [
+ *     <key>,  // Name of the key to assign the extracted number to.
+ *     <size>  // The size in bytes of the number to extract. possible values are 1, 2, 4, 8.
+ *   ],
+ *   ...
+ * ]
+ * @returns An object with keys set to their associated extracted values.
+ */
+const parse = function(buffer, format) {
+  const result = {};
+  let offset = 0;
+  for(const [key, size] of format) {
+    if(buffer.length >= offset + size) {
+      result[key] = parseUIntLE(buffer, offset, size);
+    }
+    else {
+      result[key] = null;
+    }
+    offset += size;
+  }
+  return result;
+};
+
+module.exports = {
+  parse
+};

package/lib/parseDateTime.js

@@ -0,0 +1,13 @@
+// Dates in zip file entries are stored as DosDateTime
+// Spec is here: https://docs.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-dosdatetimetofiletime
+
+module.exports = function parseDateTime(date, time) {
+  const day = date & 0x1F;
+  const month = date >> 5 & 0x0F;
+  const year = (date >> 9 & 0x7F) + 1980;
+  const seconds = time ? (time & 0x1F) * 2 : 0;
+  const minutes = time ? (time >> 5) & 0x3F : 0;
+  const hours = time ? (time >> 11): 0;
+
+  return new Date(Date.UTC(year, month-1, day, hours, minutes, seconds));
+};

package/lib/parseExtraField.js

@@ -0,0 +1,40 @@
+const parseBuffer = require('./parseBuffer');
+
+module.exports = function(extraField, vars) {
+  let extra;
+  // Find the ZIP64 header, if present.
+  while(!extra && extraField && extraField.length) {
+    const candidateExtra = parseBuffer.parse(extraField, [
+      ['signature', 2],
+      ['partSize', 2],
+    ]);
+
+    if(candidateExtra.signature === 0x0001) {
+      // parse buffer based on data in ZIP64 central directory; order is important!
+      const fieldsToExpect = [];
+      if (vars.uncompressedSize === 0xffffffff) fieldsToExpect.push(['uncompressedSize', 8]);
+      if (vars.compressedSize === 0xffffffff) fieldsToExpect.push(['compressedSize', 8]);
+      if (vars.offsetToLocalFileHeader === 0xffffffff) fieldsToExpect.push(['offsetToLocalFileHeader', 8]);
+
+      // slice off the 4 bytes for signature and partSize
+      extra = parseBuffer.parse(extraField.slice(4), fieldsToExpect);
+    } else {
+      // Advance the buffer to the next part.
+      // The total size of this part is the 4 byte header + partsize.
+      extraField = extraField.slice(candidateExtra.partSize + 4);
+    }
+  }
+
+  extra = extra || {};
+
+  if (vars.compressedSize === 0xffffffff)
+    vars.compressedSize = extra.compressedSize;
+
+  if (vars.uncompressedSize === 0xffffffff)
+    vars.uncompressedSize= extra.uncompressedSize;
+
+  if (vars.offsetToLocalFileHeader === 0xffffffff)
+    vars.offsetToLocalFileHeader = extra.offsetToLocalFileHeader;
+
+  return extra;
+};

package/lib/parseOne.js

@@ -0,0 +1,54 @@
+const Stream = require('stream');
+const Parse = require('./parse');
+const duplexer2 = require('duplexer2');
+const BufferStream = require('./BufferStream');
+
+function parseOne(match, opts) {
+  const inStream = Stream.PassThrough({objectMode:true});
+  const outStream = Stream.PassThrough();
+  const transform = Stream.Transform({objectMode:true});
+  const re = match instanceof RegExp ? match : (match && new RegExp(match));
+  let found;
+
+  transform._transform = function(entry, e, cb) {
+    if (found || (re && !re.exec(entry.path))) {
+      entry.autodrain();
+      return cb();
+    } else {
+      found = true;
+      out.emit('entry', entry);
+      entry.on('error', function(e) {
+        outStream.emit('error', e);
+      });
+      entry.pipe(outStream)
+        .on('error', function(err) {
+          cb(err);
+        })
+        .on('finish', function(d) {
+          cb(null, d);
+        });
+    }
+  };
+
+  inStream.pipe(Parse(opts))
+    .on('error', function(err) {
+      outStream.emit('error', err);
+    })
+    .pipe(transform)
+    .on('error', Object) // Silence error as its already addressed in transform
+    .on('finish', function() {
+      if (!found)
+        outStream.emit('error', new Error('PATTERN_NOT_FOUND'));
+      else
+        outStream.end();
+    });
+
+  const out = duplexer2(inStream, outStream);
+  out.buffer = function() {
+    return BufferStream(outStream);
+  };
+
+  return out;
+}
+
+module.exports = parseOne;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@zklogic/unzipper",
+  "version": "0.13.0",
+  "description": "Unzip cross-platform streaming API ",
+  "author": {
+    "email": "arfankhalil@hotmail.com",
+    "name": "Arfan Khalil Mughal",
+    "url": "https://github.com/ArfanKhalilMughal"
+  },
+  "contributors": [
+    {
+      "name": "Ziggy Jonsson",
+      "email": "ziggy.jonsson.nyc@gmail.com"
+    },
+    {
+      "name": "Evan Oxfeld",
+      "email": "eoxfeld@gmail.com"
+    },
+    {
+      "name": "Joe Ferner",
+      "email": "joe.ferner@nearinfinity.com"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ArfanKhalilMughal/node-unzipper.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "bluebird": "~3.7.2",
+    "duplexer2": "~0.1.4",
+    "fs-extra": "^11.2.0",
+    "graceful-fs": "^4.2.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.2.0",
+    "aws-sdk": "^2.1636.0",
+    "@aws-sdk/client-s3": "^3.0.0",
+    "dirdiff": ">= 0.0.1 < 1",
+    "eslint": "^9.2.0",
+    "globals": "^15.2.0",
+    "iconv-lite": "^0.4.24",
+    "request": "^2.88.0",
+    "stream-buffers": ">= 0.2.5 < 1",
+    "tap": "^16.3.10",
+    "temp": ">= 0.4.0 < 1"
+  },
+  "directories": {
+    "example": "examples",
+    "test": "test"
+  },
+  "keywords": [
+    "zip",
+    "unzip",
+    "zlib",
+    "uncompress",
+    "archive",
+    "stream",
+    "extract"
+  ],
+  "main": "unzip.js",
+  "scripts": {
+    "test": "npx tap test/*.js --coverage-report=html --lines=90 --functions=85 --statements=90 --branches=80 --reporter=dot"
+  }
+}

package/unzip.js

@@ -0,0 +1,5 @@
+'use strict';
+exports.Parse = require('./lib/parse');
+exports.ParseOne = require('./lib/parseOne');
+exports.Extract = require('./lib/extract');
+exports.Open = require('./lib/Open');