@zip.js/zip.js 2.20.0 → 2.21.0

package/lib/core/constants.js

@@ -117,6 +117,10 @@ const MIN_DATE = new Date(1980, 0, 1);
 
 const UNDEFINED_VALUE = undefined;
 const INFINITY_VALUE = Infinity;
+const ERR_LOCAL_FILE_HEADER_NOT_FOUND = "Local file header not found";
+const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
+const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
+
 const UNDEFINED_TYPE = "undefined";
 const FUNCTION_TYPE = "function";
 const OBJECT_TYPE = "object";
@@ -211,6 +215,9 @@ export {
 	MAX_DATE,
 	UNDEFINED_VALUE,
 	INFINITY_VALUE,
+	ERR_LOCAL_FILE_HEADER_NOT_FOUND,
+	ERR_OVERLAPPING_ENTRY,
+	ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
 	UNDEFINED_TYPE,
 	FUNCTION_TYPE,
 	OBJECT_TYPE,

package/lib/core/version.js

@@ -26,6 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.20.0";
+const VERSION = "2.21.0";
 
 export { VERSION };

package/lib/core/zip-reader.js

@@ -68,6 +68,9 @@ import {
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_STRONG_ENCRYPTION,
+	ERR_LOCAL_FILE_HEADER_NOT_FOUND,
+	ERR_OVERLAPPING_ENTRY,
+	ERR_EXTRAFIELD_ZIP64_NOT_FOUND,
 	BITFLAG_COMPRESSED_PATCHED_DATA,
 	BITFLAG_MASKED_LOCAL_HEADERS,
 	BITFLAG_LEVEL,
@@ -188,12 +191,9 @@ const ERR_BAD_FORMAT = "File format is not recognized";
 const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
 const ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND = "End of Zip64 central directory locator not found";
 const ERR_CENTRAL_DIRECTORY_NOT_FOUND = "Central directory header not found";
-const ERR_LOCAL_FILE_HEADER_NOT_FOUND = "Local file header not found";
-const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
 const ERR_ENCRYPTED = "File contains encrypted entry";
 const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 const ERR_SPLIT_ZIP_FILE = "Split zip file";
-const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
 const ERR_ENTRY_DATA_OUT_OF_BOUNDS = "Entry data out of bounds";
 const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const ERR_ENCRYPTED_CENTRAL_DIRECTORY = "Encrypted central directory is not supported";
@@ -258,7 +258,8 @@ class ZipReader {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
 			options,
-			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
+			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] },
+			entriesMissingZip64ExtraField: new WeakSet()
 		});
 	}
 
@@ -329,16 +330,22 @@ class ZipReader {
 				directoryDataOffset = getDiskOffset(reader, getUint32(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
 				let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 				let endOfDirectoryView = getDataView(endOfDirectoryArray);
-				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
-				if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
-					directoryDataOffset != expectedDirectoryDataOffset && expectedDirectoryDataOffset >= 0) {
-					const originalDirectoryDataOffset = directoryDataOffset;
-					directoryDataOffset = expectedDirectoryDataOffset;
-					if (directoryDataOffset > originalDirectoryDataOffset) {
-						prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+				if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+					const locatorOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH;
+					let expectedDirectoryDataOffset = locatorOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+					if (!await startsWithSignature(reader, expectedDirectoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE)) {
+						expectedDirectoryDataOffset = await findZip64EndOfDirectoryOffset(reader, locatorOffset);
+					}
+					if (expectedDirectoryDataOffset !== UNDEFINED_VALUE && expectedDirectoryDataOffset >= 0 &&
+						directoryDataOffset != expectedDirectoryDataOffset) {
+						const originalDirectoryDataOffset = directoryDataOffset;
+						directoryDataOffset = expectedDirectoryDataOffset;
+						if (directoryDataOffset > originalDirectoryDataOffset) {
+							prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+						}
+						endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+						endOfDirectoryView = getDataView(endOfDirectoryArray);
 					}
-					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
-					endOfDirectoryView = getDataView(endOfDirectoryArray);
 				}
 				if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 					throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
@@ -383,10 +390,6 @@ class ZipReader {
 		let declaredDirectoryDataLength = directoryDataLength;
 		const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
 			(zip64EndOfDirectory ? zip64EndOfDirectoryLength + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
-		if (directoryDataOffset >= reader.size) {
-			prependedDataLength = reader.size - directoryDataOffset - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
-			directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
-		}
 		if (expectedLastDiskNumber != lastDiskNumber) {
 			throw new Error(ERR_SPLIT_ZIP_FILE);
 		}
@@ -394,52 +397,64 @@ class ZipReader {
 			throw new Error(ERR_BAD_FORMAT);
 		}
 		let offset = 0;
-		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+		let directoryArray = directoryDataOffset < reader.size ?
+			await readUint8Array(reader, directoryDataOffset, directoryDataLength) :
+			EMPTY_UINT8_ARRAY;
 		let directoryView = getDataView(directoryArray);
 		if (directoryDataLength) {
-			if (directoryArray.length < 4) {
-				throw new Error(ERR_BAD_FORMAT);
-			}
 			let expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
-				const storedPointsAtDirectory = getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
+				const storedPointsAtDirectory = directoryArray.length >= 4 && (
+					getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
 					Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
-					detectEncryptedCentralDirectory(directoryView);
+					detectEncryptedCentralDirectory(directoryView));
+				if (!storedPointsAtDirectory && expectedDirectoryDataOffset < 0) {
+					throw new Error(ERR_BAD_FORMAT);
+				}
 				let reconcile = !storedPointsAtDirectory;
 				if (expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
-					const expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
-					if (storedPointsAtDirectory) {
-						reconcile = expectedPointsAtDirectory;
-					} else if (!expectedPointsAtDirectory) {
+					let expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
+					if (!expectedPointsAtDirectory) {
 						const signatureRecordOffset = await findDigitalSignatureRecordOffset(reader, centralDirectoryEndOffset);
 						const signedDirectoryDataOffset = signatureRecordOffset - directoryDataLength;
 						if (signatureRecordOffset !== UNDEFINED_VALUE && signedDirectoryDataOffset >= 0 &&
 							await pointsAtDirectory(reader, signedDirectoryDataOffset)) {
 							expectedDirectoryDataOffset = signedDirectoryDataOffset;
+							expectedPointsAtDirectory = true;
 						}
 					}
+					if (storedPointsAtDirectory) {
+						reconcile = expectedPointsAtDirectory;
+					}
 				}
-				if (reconcile) {
+				if (reconcile && expectedDirectoryDataOffset != directoryDataOffset) {
 					const originalDirectoryDataOffset = directoryDataOffset;
 					directoryDataOffset = expectedDirectoryDataOffset;
 					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 					directoryView = getDataView(directoryArray);
-					if (directoryDataOffset > originalDirectoryDataOffset) {
-						prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+					const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
+					const localHeaderOffset = getFirstLocalHeaderOffset(directoryArray, directoryView);
+					const localHeaderFound = localHeaderOffset !== UNDEFINED_VALUE &&
+						await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE);
+					const shiftedLocalHeaderFound = localHeaderOffset !== UNDEFINED_VALUE &&
+						await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE);
+					if (offsetDelta > 0 && !(localHeaderFound && !shiftedLocalHeaderFound)) {
+						prependedDataLength += offsetDelta;
 						prependedCentralDirectory = storedPointsAtDirectory;
 					} else {
 						reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET);
-						const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
-						if (directoryArray.length >= CENTRAL_FILE_HEADER_LENGTH) {
-							const localHeaderOffset = getUint32(directoryView, 42);
-							if (!await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE) &&
-								await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE)) {
-								prependedDataLength += offsetDelta;
-							}
+						if (offsetDelta < 0 && !localHeaderFound && shiftedLocalHeaderFound) {
+							prependedDataLength += offsetDelta;
 						}
 					}
 				}
 			}
+			if (directoryArray.length < 4) {
+				throw new Error(ERR_BAD_FORMAT);
+			}
+		} else if (!filesLength && directoryDataOffset < centralDirectoryEndOffset && diskNumber == lastDiskNumber) {
+			prependedDataLength += centralDirectoryEndOffset - directoryDataOffset;
+			directoryDataOffset = centralDirectoryEndOffset;
 		}
 		const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset;
 		if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
@@ -481,8 +496,10 @@ class ZipReader {
 				addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
 			}
 		}
+		const entryOptions = Object.assign({}, zipReader.options, options, { [OPTION_STRICTNESS]: strictness });
+		delete entryOptions[OPTION_CHECK_AMBIGUITY];
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
-			const fileEntry = new ZipEntry(reader, zipReader.options);
+			const fileEntry = new ZipEntry(reader, entryOptions);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 				if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
@@ -573,13 +590,17 @@ class ZipReader {
 			if (malformedExtraField) {
 				addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
 			}
-			fileEntry.offset += prependedDataLength;
-			const entryPosition = getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset;
-			startOffset = Math.min(entryPosition, startOffset);
-			if (entryPosition < previousEntryPosition) {
-				addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+			if (fileEntry.zip64ExtraFieldMissing && fileEntry.offset == MAX_32_BITS) {
+				startOffset = 0;
+			} else {
+				fileEntry.offset += prependedDataLength;
+				const entryPosition = getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset;
+				startOffset = Math.min(entryPosition, startOffset);
+				if (entryPosition < previousEntryPosition) {
+					addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+				}
+				previousEntryPosition = entryPosition;
 			}
-			previousEntryPosition = entryPosition;
 			if ((fileEntry.version & MAX_8_BITS) > MAX_KNOWN_VERSION) {
 				addWarning(warnings, WARNING_UNKNOWN_VERSION, filename);
 			}
@@ -616,12 +637,15 @@ class ZipReader {
 				zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
 			});
 			const entry = new Entry(fileEntry);
-			entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader.readRanges, options);
+			if (fileEntry.zip64ExtraFieldMissing) {
+				zipReader.entriesMissingZip64ExtraField.add(entry);
+			}
+			entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader, options);
 			entry.arrayBuffer = async options => {
 				const writer = new TransformStream();
 				const arrayBufferPromise = streamToBlob(writer.readable).then(blob => blob.arrayBuffer());
 				arrayBufferPromise.catch(() => { });
-				await fileEntry.getData(writer, entry, zipReader.readRanges,
+				await fileEntry.getData(writer, entry, zipReader,
 					Object.assign({}, options, { preventClose: false }));
 				return arrayBufferPromise;
 			};
@@ -824,6 +848,7 @@ export {
 	ZipReader,
 	isZipFile,
 	ZipReaderStream,
+	getEntryDataDescriptorLength,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
 	ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND,
@@ -880,8 +905,9 @@ class ZipEntry {
 		});
 	}
 
-	async getData(writer, fileEntry, readRanges, options = {}) {
+	async getData(writer, fileEntry, zipReader, options = {}) {
 		const zipEntry = this;
+		const { readRanges, directoryOffset } = zipReader;
 		if (zipEntry.zip64ExtraFieldMissing) {
 			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
 		}
@@ -955,10 +981,10 @@ class ZipEntry {
 		}
 		validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
-		if (lastAccessDate) {
+		if (lastAccessDate && fileEntry.lastAccessDate === UNDEFINED_VALUE) {
 			fileEntry.lastAccessDate = lastAccessDate;
 		}
-		if (creationDate) {
+		if (creationDate && fileEntry.creationDate === UNDEFINED_VALUE) {
 			fileEntry.creationDate = creationDate;
 		}
 		if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
@@ -987,7 +1013,7 @@ class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		if (dataOffset + compressedSize > reader.size) {
+		if (dataOffset + compressedSize > Math.min(reader.size, directoryOffset)) {
 			throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
 		}
 		const size = compressedSize;
@@ -1053,6 +1079,7 @@ class ZipEntry {
 				extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
 				readRanges
 			});
+			validateDataDescriptor(zipEntry, localDirectory, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 		}
 		let writable, abortError, aborted;
 		try {
@@ -1072,10 +1099,7 @@ class ZipEntry {
 				writer.size += writtenSize;
 			}
 		} catch (error) {
-			const { outputSize: failedOutputSize } = workerOptions;
-			if (failedOutputSize !== UNDEFINED_VALUE) {
-				writer.size += failedOutputSize;
-			} else if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
+			if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
 			}
 			if (!checkPasswordOnly || !isErrorObject(error) || error.message != ERR_ABORT_CHECK_PASSWORD) {
@@ -1103,13 +1127,7 @@ class ZipEntry {
 }
 
 function detectEncryptedCentralDirectory(directoryView) {
-	const maxOffset = Math.min(directoryView.byteLength, 1024) - 3;
-	for (let offset = 0; offset < maxOffset; offset++) {
-		if (getUint32(directoryView, offset) == ARCHIVE_EXTRA_DATA_SIGNATURE) {
-			return true;
-		}
-	}
-	return false;
+	return directoryView.byteLength >= 4 && getUint32(directoryView, 0) == ARCHIVE_EXTRA_DATA_SIGNATURE;
 }
 
 function getWrappedFilesLength(directoryView, directoryArray, offset) {
@@ -1146,6 +1164,46 @@ async function findDigitalSignatureRecordOffset(reader, endOffset) {
 	}
 }
 
+async function findZip64EndOfDirectoryOffset(reader, endOffset) {
+	const startOffset = Math.max(0, endOffset - (ZIP64_END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS));
+	const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+	const tailView = getDataView(tailArray);
+	for (let indexByte = tailArray.length - ZIP64_END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
+		if (getUint32(tailView, indexByte) == ZIP64_END_OF_CENTRAL_DIR_SIGNATURE &&
+			indexByte + 12 + Number(tailView.getBigUint64(indexByte + 4, true)) == tailArray.length) {
+			return startOffset + indexByte;
+		}
+	}
+}
+
+function getFirstLocalHeaderOffset(directoryArray, directoryView) {
+	if (directoryArray.length < CENTRAL_FILE_HEADER_LENGTH) {
+		return UNDEFINED_VALUE;
+	}
+	const localHeaderOffset = getUint32(directoryView, 42);
+	if (localHeaderOffset != MAX_32_BITS) {
+		return localHeaderOffset;
+	}
+	let offsetExtraField = CENTRAL_FILE_HEADER_LENGTH + getUint16(directoryView, 28);
+	const endExtraField = Math.min(offsetExtraField + getUint16(directoryView, 30), directoryArray.length);
+	while (offsetExtraField + 4 <= endExtraField) {
+		const type = getUint16(directoryView, offsetExtraField);
+		const size = getUint16(directoryView, offsetExtraField + 2);
+		if (type == EXTRAFIELD_TYPE_ZIP64) {
+			let offsetValue = offsetExtraField + 4;
+			if (getUint32(directoryView, 24) == MAX_32_BITS) {
+				offsetValue += 8;
+			}
+			if (getUint32(directoryView, 20) == MAX_32_BITS) {
+				offsetValue += 8;
+			}
+			return offsetValue + 8 <= endExtraField ? getBigUint64(directoryView, offsetValue) : UNDEFINED_VALUE;
+		}
+		offsetExtraField += 4 + size;
+	}
+	return UNDEFINED_VALUE;
+}
+
 function readDigitalSignature(signatureRecordArray) {
 	if (signatureRecordArray.length >= 6) {
 		const signatureRecordView = getDataView(signatureRecordArray);
@@ -1235,6 +1293,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		uncompressedSize: getUint32(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
 	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
+	let extraFieldZip64Missing;
 	if (extraFieldZip64) {
 		if (!readExtraFieldZip64(extraFieldZip64, directory, localDirectory)) {
 			malformedExtraField = true;
@@ -1244,7 +1303,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		if (localDirectory) {
 			malformedExtraField = true;
 		} else {
-			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+			extraFieldZip64Missing = true;
 		}
 	}
 	const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
@@ -1302,6 +1361,9 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	if (extraFieldUSDZ) {
 		directory.extraFieldUSDZ = extraFieldUSDZ;
 	}
+	if (extraFieldZip64Missing) {
+		throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+	}
 	return malformedExtraField;
 }
 
@@ -1516,13 +1578,7 @@ async function detectOverlappingEntry({
 	let dataDescriptorLength = 0;
 	if (dataDescriptor) {
 		const zip64 = Boolean(extraFieldZip64);
-		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-		const dataDescriptorView = getDataView(dataDescriptorArray);
-		const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]
-			.map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature))
-			.filter(candidate => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
-		const localDataDescriptor = candidates.find(candidate => candidate.crc32 == crc32) || candidates[0] ||
-			readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
+		const localDataDescriptor = await readLocalDataDescriptor(reader, dataOffset + compressedSize, { crc32, compressedSize, uncompressedSize, zip64 });
 		if (localDataDescriptor) {
 			fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
 			dataDescriptorLength = getDataDescriptorLength(localDataDescriptor.zip64, localDataDescriptor.signature);
@@ -1592,6 +1648,25 @@ function mergeRanges(sortedRanges, pendingRanges) {
 	return mergedRanges;
 }
 
+async function readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64 }) {
+	const maxLength = DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+	const length = Math.min(maxLength, Math.max(0, reader.size - offset));
+	const dataDescriptorArray = length ? await readUint8Array(reader, offset, length) : EMPTY_UINT8_ARRAY;
+	const dataDescriptorView = getDataView(dataDescriptorArray);
+	const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]
+		.map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature))
+		.filter(candidate => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
+	return candidates.find(candidate => candidate.crc32 == crc32) || candidates[0] ||
+		readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
+}
+
+async function getEntryDataDescriptorLength(reader, offset, { crc32, compressedSize, uncompressedSize, extraFieldZip64 }) {
+	const dataDescriptor = await readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64: Boolean(extraFieldZip64) });
+	if (dataDescriptor && dataDescriptor.compressedSize == compressedSize && dataDescriptor.uncompressedSize == uncompressedSize) {
+		return getDataDescriptorLength(dataDescriptor.zip64, dataDescriptor.signature);
+	}
+}
+
 function readDataDescriptor(dataDescriptorView, zip64, signature) {
 	const offset = signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0;
 	if (dataDescriptorView.byteLength < getDataDescriptorLength(zip64, signature) ||
@@ -1851,6 +1926,18 @@ function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, chec
 	}
 }
 
+function validateDataDescriptor(zipEntry, localDirectory, warnings) {
+	const { dataDescriptor } = localDirectory;
+	const maskedLocalDirectory = zipEntry.decryptedDirectory &&
+		(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+	if (dataDescriptor && !maskedLocalDirectory &&
+		((zipEntry.crc32 !== UNDEFINED_VALUE && dataDescriptor.crc32 != zipEntry.crc32) ||
+			dataDescriptor.compressedSize != zipEntry.compressedSize ||
+			dataDescriptor.uncompressedSize != zipEntry.uncompressedSize)) {
+		reportAmbiguity(!warnings, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES);
+	}
+}
+
 function reportAmbiguity(reject, warnings, reason) {
 	if (reject) {
 		throwAmbiguousArchive(reason);