Add option to recover corrupted zips

Needs more work to improve reliability, but this is better than nothing.

#2

Author: GarboMuffin

lib/zipEntries.js

@@ -245,15 +245,85 @@ ZipEntries.prototype = {
     prepareReader: function(data) {
         this.reader = readerFor(data);
     },
+    /**
+     * Attempt to parse a zip without a central directory.
+     */
+    tryRecoverCorruptedZip: function() {
+        // Undo anything done by the central directory reader
+        this.reader.setIndex(0);
+        this.files = [];
+
+        // Zip comment is in central directory, so we have no comment
+        this.zipCommentLength = 0;
+        this.zipComment = [];
+
+        let possibleHeaders = 0;
+
+        // Without central directory, have to just search for file entry magic bytes
+        const length = this.reader.length;
+        for (let i = 0; i < length - 4; i++) {
+            if (
+                this.reader.byteAt(i) === 0x50 &&
+                this.reader.byteAt(i + 1) === 0x4B &&
+                this.reader.byteAt(i + 2) === 0x03 &&
+                this.reader.byteAt(i + 3) === 0x04
+            ) {
+                possibleHeaders++;
+                const zipEntry = this.tryRecoverFileEntry(i);
+                if (zipEntry) {
+                    this.files.push(zipEntry);
+                }
+            }
+        }
+
+        if (this.files.length === 0) {
+            if (possibleHeaders === 0) {
+                throw new Error("Corrupted zip: no central directory or any file headers");
+            }
+            throw new Error(`Corrupted zip: no central directory, and ${possibleHeaders} possible local headers could not be recovered`);
+        }
+    },
+    /**
+     * Attempts to read a zip entry from only the local header.
+     * @param {number} index Index in this.reader where a file header appears to start
+     * @returns {ZipEntry|null} The zip entry if a valid one could be parsed, otherwise null.
+     */
+    tryRecoverFileEntry: function(index) {
+        this.reader.setIndex(index);
+
+        const zipEntry = new ZipEntry({
+            zip64: this.zip64
+        }, this.loadOptions);
+
+        try {
+            zipEntry.readLocalPartFromCorruptedZip(this.reader);
+            zipEntry.handleUTF8();
+            zipEntry.processAttributes();
+            return zipEntry;
+        } catch (e) {
+            // Entry is invalid.
+            console.error(e);
+            return null;
+        }
+    },
     /**
      * Read a zip file and create ZipEntries.
      * @param {String|ArrayBuffer|Uint8Array|Buffer} data the binary string representing a zip file.
      */
     load: function(data) {
         this.prepareReader(data);
-        this.readEndOfCentral();
-        this.readCentralDir();
-        this.readLocalFiles();
+
+        try {
+            this.readEndOfCentral();
+            this.readCentralDir();
+            this.readLocalFiles();
+        } catch (error) {
+            if (this.loadOptions.recoverCorrupted) {
+                this.tryRecoverCorruptedZip();
+            } else {
+                throw error;
+            }
+        }
     }
 };
 // }}} end of ZipEntries

lib/zipEntry.js

@@ -6,6 +6,7 @@ var crc32fn = require("./crc32");
 var utf8 = require("./utf8");
 var compressions = require("./compressions");
 var support = require("./support");
+var sig = require("./signature");
 
 var MADE_BY_DOS = 0x00;
 var MADE_BY_UNIX = 0x03;
@@ -129,6 +130,36 @@ ZipEntry.prototype = {
         this.fileComment = reader.readData(this.fileCommentLength);
     },
 
+    /**
+     * Reads the local part of a zip file. Used when the central part of the zip is missing.
+     * @param {DataReader} reader Reader pointing to the start of local part header signature
+     * @throws if the header is invalid
+     */
+    readLocalPartFromCorruptedZip: function(reader) {
+        // Read everything in the possible header
+        reader.readAndCheckSignature(sig.LOCAL_FILE_HEADER);
+        this.versionMadeBy = reader.readInt(2);
+        this.bitFlag = reader.readInt(2);
+        this.compressionMethod = reader.readString(2);
+        this.date = reader.readDate();
+        this.crc32 = reader.readInt(4);
+        this.compressedSize = reader.readInt(4);
+        this.uncompressedSize = reader.readInt(4);
+        this.fileNameLength = reader.readInt(2);
+        this.extraFieldsLength = reader.readInt(2);
+        this.fileName = reader.readData(this.fileNameLength);
+        this.readExtraFields(reader);
+        this.parseZIP64ExtraField(reader);
+
+        // TODO: more checks to verify that the header makes sense
+
+        var compression = findCompression(this.compressionMethod);
+        if (compression === null) {
+            throw new Error("Corrupted zip : compression " + utils.pretty(this.compressionMethod) + " unknown (inner file : " + utils.transformTo("string", this.fileName) + ")");
+        }
+        this.decompressed = new CompressedObject(this.compressedSize, this.uncompressedSize, this.crc32, compression, reader.readData(this.compressedSize));
+    },
+
     /**
      * Parse the external file attributes and get the unix/dos permissions.
      */

test/asserts/corruption.js

@@ -0,0 +1,19 @@
+"use strict";
+
+QUnit.module("corruption", function () {
+    JSZipTestUtils.testZipFile("load(string) works", "ref/no-central-directory/truncated.zip", function(assert, file) {
+        var done = assert.async();
+        JSZip.loadAsync(file, {
+            recoverCorrupted: true
+        })
+            .then(function (zip) {
+                return zip.file("project.json").async("string");
+            })
+            .then(function(result) {
+                const parsed = JSON.parse(result);
+                assert.equal(parsed.targets[0].name, "Stage");
+                done();
+            })
+            .catch(JSZipTestUtils.assertNoError);
+    });
+});