@zip.js/zip.js 2.8.26 → 2.8.29

package/lib/core/zip-reader.js

@@ -43,6 +43,7 @@ import {
 	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
+	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
@@ -93,6 +94,7 @@ import {
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
+	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD
 } from "./codec-pool.js";
 import {
@@ -134,6 +136,7 @@ import {
 	OPTION_CHECK_PASSWORD_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY,
+	OPTION_CHECK_AMBIGUITY,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,
@@ -152,9 +155,13 @@ const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const ERR_SPLIT_ZIP_FILE = "Split zip file";
 const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
+const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 const CHARSET_CP437 = "cp437";
+// bits of the general purpose flag that change how an entry is interpreted; the level bits (1-2) are excluded
+// because they are informative only
+const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
 const ZIP64_PROPERTIES = [
 	[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
 	[PROPERTY_NAME_COMPRESSED_SIZE, MAX_32_BITS],
@@ -179,7 +186,7 @@ class ZipReader {
 			reader: new GenericReader(reader),
 			options,
 			config: getConfiguration(),
-			readRanges: []
+			readRanges: new Map()
 		});
 	}
 
@@ -212,21 +219,30 @@ class ZipReader {
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+		const checkAmbiguity = getOptionValue(zipReader, options, OPTION_CHECK_AMBIGUITY);
+		if (checkAmbiguity && appendedDataOffset != reader.size) {
+			throwAmbiguousArchive("appended data");
+		}
 		let lastDiskNumber = getUint16(endOfDirectoryView, 4);
 		const expectedLastDiskNumber = reader.lastDiskNumber || 0;
 		let diskNumber = getUint16(endOfDirectoryView, 6);
-		let filesLength = getUint16(endOfDirectoryView, 8);
+		let filesLength = getUint16(endOfDirectoryView, 10);
 		let prependedDataLength = 0;
-		let startOffset = 0;
+		let startOffset;
+		let zip64EndOfDirectory;
 		if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS) {
-			const endOfDirectoryLocatorArray = await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH);
+			const endOfDirectoryLocatorArray = endOfDirectoryInfo.offset >= ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH ?
+				await readUint8Array(reader, endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH) :
+				new Uint8Array();
 			const endOfDirectoryLocatorView = getDataView(endOfDirectoryLocatorArray);
-			if (getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
+			if (endOfDirectoryLocatorArray.length == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH &&
+				getUint32(endOfDirectoryLocatorView, 0) == ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE) {
 				directoryDataOffset = getBigUint64(endOfDirectoryLocatorView, 8);
 				let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
 				let endOfDirectoryView = getDataView(endOfDirectoryArray);
-				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
-				if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
+				const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH - (reader.lastDiskOffset || 0);
+				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) {
@@ -235,24 +251,36 @@ class ZipReader {
 					endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH, -1);
 					endOfDirectoryView = getDataView(endOfDirectoryArray);
 				}
-				if (getUint32(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+				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);
 				}
+				zip64EndOfDirectory = true;
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32(endOfDirectoryView, 16);
+				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
+					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
 				if (diskNumber == MAX_16_BITS) {
 					diskNumber = getUint32(endOfDirectoryView, 20);
+				} else if (checkAmbiguity && diskNumber != getUint32(endOfDirectoryView, 20)) {
+					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
 				if (filesLength == MAX_16_BITS) {
 					filesLength = getBigUint64(endOfDirectoryView, 32);
+				} else if (checkAmbiguity && filesLength != getBigUint64(endOfDirectoryView, 32)) {
+					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
 				if (directoryDataLength == MAX_32_BITS) {
 					directoryDataLength = getBigUint64(endOfDirectoryView, 40);
+				} else if (checkAmbiguity && directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
+					throwAmbiguousArchive("mismatched zip64 end of central directory record");
 				}
-				directoryDataOffset -= directoryDataLength;
+				directoryDataOffset = getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
 		}
+		const declaredDirectoryDataLength = directoryDataLength;
+		const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
+			(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + 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;
@@ -267,8 +295,11 @@ class ZipReader {
 		let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
 		let directoryView = getDataView(directoryArray);
 		if (directoryDataLength) {
-			const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - directoryDataLength;
-			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset) {
+			if (directoryArray.length < 4) {
+				throw new Error(ERR_BAD_FORMAT);
+			}
+			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength - (reader.lastDiskOffset || 0);
+			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE && directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
 				const originalDirectoryDataOffset = directoryDataOffset;
 				directoryDataOffset = expectedDirectoryDataOffset;
 				if (directoryDataOffset > originalDirectoryDataOffset) {
@@ -278,8 +309,8 @@ class ZipReader {
 				directoryView = getDataView(directoryArray);
 			}
 		}
-		const expectedDirectoryDataLength = endOfDirectoryInfo.offset - directoryDataOffset - (reader.lastDiskOffset || 0);
-		if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0) {
+		const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset - (reader.lastDiskOffset || 0);
+		if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
 			directoryDataLength = expectedDirectoryDataLength;
 			directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength, diskNumber);
 			directoryView = getDataView(directoryArray);
@@ -287,16 +318,19 @@ class ZipReader {
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
+		startOffset = directoryDataOffset;
 		const filenameEncoding = getOptionValue(zipReader, options, OPTION_FILENAME_ENCODING);
 		const commentEncoding = getOptionValue(zipReader, options, OPTION_COMMENT_ENCODING);
+		const filenames = checkAmbiguity ? new Set() : UNDEFINED_VALUE;
+		let duplicateFilename;
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry(reader, config, zipReader.options);
-			if (getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
+			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 				throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
 			}
 			readCommonHeader(fileEntry, directoryView, offset + 6);
 			const languageEncodingFlag = Boolean(fileEntry.bitFlag.languageEncodingFlag);
-			const filenameOffset = offset + 46;
+			const filenameOffset = offset + CENTRAL_FILE_HEADER_LENGTH;
 			const extraFieldOffset = filenameOffset + fileEntry.filenameLength;
 			const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
 			const versionMadeBy = getUint16(directoryView, offset + 4);
@@ -317,7 +351,7 @@ class ZipReader {
 				directory: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_DIR_MASK),
 				archive: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_ARCHIVE_MASK)
 			};
-			const offsetFileEntry = getUint32(directoryView, offset + 42) + prependedDataLength;
+			const offsetFileEntry = getUint32(directoryView, offset + 42);
 			const decode = getOptionValue(zipReader, options, OPTION_DECODE_TEXT) || decodeText;
 			const rawFilenameEncoding = filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437;
 			const rawCommentEncoding = commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437;
@@ -330,6 +364,7 @@ class ZipReader {
 				comment = decodeText(rawComment, rawCommentEncoding);
 			}
 			Object.assign(fileEntry, {
+				index: indexFile,
 				versionMadeBy,
 				msDosCompatible,
 				compressedSize: 0,
@@ -349,8 +384,15 @@ class ZipReader {
 				filename,
 				comment
 			});
-			startOffset = Math.max(offsetFileEntry, startOffset);
 			readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			fileEntry.offset += prependedDataLength;
+			startOffset = Math.min(fileEntry.offset, startOffset);
+			if (checkAmbiguity) {
+				if (filenames.has(fileEntry.filename)) {
+					duplicateFilename = true;
+				}
+				filenames.add(fileEntry.filename);
+			}
 			const unixExternalUpper = (fileEntry.externalFileAttributes >> 16) & MAX_16_BITS;
 			if (fileEntry.unixMode === UNDEFINED_VALUE && (unixExternalUpper & (FILE_ATTR_UNIX_DEFAULT_MASK | FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_TYPE_DIR)) != 0) {
 				fileEntry.unixMode = unixExternalUpper;
@@ -371,7 +413,7 @@ class ZipReader {
 				internalFileAttribute: fileEntry.internalFileAttributes,
 				externalFileAttribute: fileEntry.externalFileAttributes,
 				executable,
-				directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || (filename.endsWith(DIRECTORY_SIGNATURE) && !fileEntry.uncompressedSize),
+				directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || (fileEntry.filename.endsWith(DIRECTORY_SIGNATURE) && !fileEntry.uncompressedSize),
 				zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
 			});
 			const entry = new Entry(fileEntry);
@@ -394,6 +436,15 @@ class ZipReader {
 			}
 			yield entry;
 		}
+		if (checkAmbiguity && offset != declaredDirectoryDataLength) {
+			throwAmbiguousArchive("trailing central directory data");
+		}
+		if (duplicateFilename) {
+			throwAmbiguousArchive("duplicate filename");
+		}
+		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > 0))) {
+			throwAmbiguousArchive("prepended data");
+		}
 		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		if (extractPrependedData) {
@@ -433,9 +484,21 @@ class ZipReaderStream {
 					readable: (function () {
 						const { readable, writable } = new TransformStream();
 						if (value.getData) {
-							value.getData(writable);
+							getData();
 							return readable;
 						}
+
+						async function getData() {
+							try {
+								await value.getData(writable);
+							} catch (error) {
+								try {
+									await writable.abort(error);
+								} catch {
+									// ignored
+								}
+							}
+						}
 					})()
 				};
 				delete chunk.getData;
@@ -461,8 +524,10 @@ export {
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
+	ERR_INVALID_COMPRESSED_DATA,
 	ERR_SPLIT_ZIP_FILE,
-	ERR_OVERLAPPING_ENTRY
+	ERR_OVERLAPPING_ENTRY,
+	ERR_AMBIGUOUS_ARCHIVE
 };
 
 class ZipEntry {
@@ -479,6 +544,7 @@ class ZipEntry {
 		const zipEntry = this;
 		const {
 			reader,
+			index,
 			offset,
 			diskNumberStart,
 			extraFieldAES,
@@ -510,21 +576,36 @@ class ZipEntry {
 		if ((compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64) && !passThrough) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
-		if (getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
+		if (dataArray.length < HEADER_SIZE || getUint32(dataView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
 			throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
 		}
 		readCommonHeader(localDirectory, dataView, 4);
 		const {
 			extraFieldLength,
-			filenameLength,
-			lastAccessDate,
-			creationDate
+			filenameLength
 		} = localDirectory;
-		localDirectory.rawExtraField = extraFieldLength ?
-			await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
-			new Uint8Array();
+		const checkAmbiguity = getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY);
+		let rawLocalFilename = new Uint8Array();
+		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
+			const trailingDataArray = await readUint8Array(reader, offset + HEADER_SIZE, filenameLength + extraFieldLength, diskNumberStart);
+			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
+			localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
+		} else {
+			localDirectory.rawExtraField = extraFieldLength ?
+				await readUint8Array(reader, offset + HEADER_SIZE + filenameLength, extraFieldLength, diskNumberStart) :
+				new Uint8Array();
+		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		Object.assign(fileEntry, { lastAccessDate, creationDate });
+		if (checkAmbiguity) {
+			checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename);
+		}
+		const { lastAccessDate, creationDate } = localDirectory;
+		if (lastAccessDate) {
+			fileEntry.lastAccessDate = lastAccessDate;
+		}
+		if (creationDate) {
+			fileEntry.creationDate = creationDate;
+		}
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThrough) {
@@ -570,7 +651,7 @@ class ZipEntry {
 				outputSize: passThrough ? compressedSize : uncompressedSize,
 				signature,
 				compressed: compressionMethod != 0 && !passThrough,
-				encrypted: zipEntry.encrypted && !passThrough,
+				encrypted,
 				useWebWorkers: getOptionValue(zipEntry, options, OPTION_USE_WEB_WORKERS),
 				useCompressionStream,
 				transferStreams: getOptionValue(zipEntry, options, OPTION_TRANSFER_STREAMS),
@@ -584,6 +665,7 @@ class ZipEntry {
 			await detectOverlappingEntry({
 				reader,
 				fileEntry,
+				index,
 				offset,
 				diskNumberStart,
 				signature,
@@ -686,7 +768,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
 	}
 	const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
-	if (extraFieldAES) {
+	if (extraFieldAES && extraFieldAES.data.length >= 7) {
 		readExtraFieldAES(extraFieldAES, directory, compressionMethod);
 		directory.extraFieldAES = extraFieldAES;
 	} else {
@@ -723,19 +805,23 @@ function readExtraFieldZip64(extraFieldZip64, directory) {
 	directory.zip64 = true;
 	const extraFieldView = getDataView(extraFieldZip64.data);
 	const missingProperties = ZIP64_PROPERTIES.filter(([propertyName, max]) => directory[propertyName] == max);
+	const requiredLength = missingProperties.reduce((length, [, max]) => length + ZIP64_EXTRACTION[max].bytes, 0);
+	if (extraFieldZip64.data.length < requiredLength) {
+		throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+	}
 	for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
 		const [propertyName, max] = missingProperties[indexMissingProperty];
-		if (directory[propertyName] == max) {
-			const extraction = ZIP64_EXTRACTION[max];
-			directory[propertyName] = extraFieldZip64[propertyName] = extraction.getValue(extraFieldView, offset);
-			offset += extraction.bytes;
-		} else if (extraFieldZip64[propertyName]) {
-			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
-		}
+		const extraction = ZIP64_EXTRACTION[max];
+		directory[propertyName] = extraFieldZip64[propertyName] = extraction.getValue(extraFieldView, offset);
+		offset += extraction.bytes;
 	}
 }
 
 function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
+	if (extraFieldUnicode.data.length < 5) {
+		extraFieldUnicode.valid = false;
+		return;
+	}
 	const extraFieldView = getDataView(extraFieldUnicode.data);
 	const crc32 = new Crc32();
 	crc32.append(fileEntry[rawPropertyName]);
@@ -808,32 +894,30 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 function readExtraFieldUnix(extraField, directory, isInfoZip) {
 	try {
 		const view = getDataView(new Uint8Array(extraField.data));
-		let offset = 0;
-		const version = getUint8(view, offset++);
-		const uidSize = getUint8(view, offset++);
-		const uidBytes = extraField.data.subarray(offset, offset + uidSize);
-		offset += uidSize;
-		const uid = unpackUnixId(uidBytes);
-		const gidSize = getUint8(view, offset++);
-		const gidBytes = extraField.data.subarray(offset, offset + gidSize);
-		offset += gidSize;
-		const gid = unpackUnixId(gidBytes);
-		let unixMode = UNDEFINED_VALUE;
-		if (!isInfoZip && offset + 2 <= extraField.data.length) {
-			const base = extraField.data;
-			const modeView = new DataView(base.buffer, base.byteOffset + offset, 2);
-			unixMode = modeView.getUint16(0, true);
-		}
-		Object.assign(extraField, { version, uid, gid, unixMode });
+		let uid, gid;
+		if (isInfoZip) {
+			// Info-ZIP New Unix "ux" field (0x7875): version + variable-length uid/gid
+			let offset = 0;
+			const version = getUint8(view, offset++);
+			const uidSize = getUint8(view, offset++);
+			uid = unpackUnixId(extraField.data.subarray(offset, offset + uidSize));
+			offset += uidSize;
+			const gidSize = getUint8(view, offset++);
+			gid = unpackUnixId(extraField.data.subarray(offset, offset + gidSize));
+			Object.assign(extraField, { version, uid, gid });
+		} else if (extraField.data.length >= 4) {
+			// Info-ZIP Unix "Ux" field (0x7855): fixed 2-byte uid + gid (the file mode, if any, is
+			// carried in the external file attributes, not here)
+			uid = getUint16(view, 0);
+			gid = getUint16(view, 2);
+			Object.assign(extraField, { uid, gid });
+		}
 		if (uid !== UNDEFINED_VALUE) {
 			directory.uid = uid;
 		}
 		if (gid !== UNDEFINED_VALUE) {
 			directory.gid = gid;
 		}
-		if (unixMode !== UNDEFINED_VALUE) {
-			directory.unixMode = unixMode;
-		}
 	} catch {
 		// ignored
 	}
@@ -847,6 +931,9 @@ function unpackUnixId(bytes) {
 }
 
 function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory) {
+	if (!extraFieldExtendedTimestamp.data.length) {
+		return;
+	}
 	const extraFieldView = getDataView(extraFieldExtendedTimestamp.data);
 	const flags = getUint8(extraFieldView, 0);
 	const timeProperties = [];
@@ -872,7 +959,8 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 	timeProperties.forEach((propertyName, indexProperty) => {
 		if (extraFieldExtendedTimestamp.data.length >= offset + 4) {
 			const time = getUint32(extraFieldView, offset);
-			directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date(time * 1000);
+			// the extended timestamp is a signed 32-bit time_t value
+			directory[propertyName] = extraFieldExtendedTimestamp[propertyName] = new Date((time | 0) * 1000);
 			const rawPropertyName = timeRawProperties[indexProperty];
 			extraFieldExtendedTimestamp[rawPropertyName] = time;
 		}
@@ -883,6 +971,7 @@ function readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory,
 async function detectOverlappingEntry({
 	reader,
 	fileEntry,
+	index,
 	offset,
 	diskNumberStart,
 	signature,
@@ -894,10 +983,9 @@ async function detectOverlappingEntry({
 	readRanges
 }) {
 	let diskOffset = 0;
-	if (diskNumberStart) {
-		for (let indexReader = 0; indexReader < diskNumberStart; indexReader++) {
-			const diskReader = reader.readers[indexReader];
-			diskOffset += diskReader.size;
+	if (diskNumberStart && reader.readers) {
+		for (let indexReader = 0; indexReader < Math.min(diskNumberStart, reader.readers.length); indexReader++) {
+			diskOffset += reader.readers[indexReader].size;
 		}
 	}
 	let dataDescriptorLength = 0;
@@ -910,7 +998,8 @@ async function detectOverlappingEntry({
 	}
 	if (dataDescriptorLength) {
 		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, diskNumberStart);
-		const dataDescriptorSignature = getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+		const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
+			getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
 		if (dataDescriptorSignature) {
 			const readSignature = getUint32(getDataView(dataDescriptorArray), 4);
 			let readCompressedSize;
@@ -935,14 +1024,14 @@ async function detectOverlappingEntry({
 		end: diskOffset + dataOffset + compressedSize + dataDescriptorLength,
 		fileEntry
 	};
-	for (const otherRange of readRanges) {
-		if (otherRange.fileEntry != fileEntry && range.start >= otherRange.start && range.start < otherRange.end) {
+	for (const [otherIndex, otherRange] of readRanges) {
+		if (otherIndex != index && range.start < otherRange.end && otherRange.start < range.end) {
 			const error = new Error(ERR_OVERLAPPING_ENTRY);
 			error.overlappingEntry = otherRange.fileEntry;
 			throw error;
 		}
 	}
-	readRanges.push(range);
+	readRanges.set(index, range);
 }
 
 async function seekSignature(reader, signature, startOffset, minimumBytes, maximumLength) {
@@ -967,6 +1056,35 @@ async function seekSignature(reader, signature, startOffset, minimumBytes, maxim
 	}
 }
 
+function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
+	const { rawFilename } = zipEntry;
+	if (rawLocalFilename.length != rawFilename.length ||
+		rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte])) {
+		throwAmbiguousArchive("mismatched local file header (filename)");
+	}
+	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
+		throwAmbiguousArchive("mismatched local file header (general purpose bit flag)");
+	}
+	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
+		throwAmbiguousArchive("mismatched local file header (compression method)");
+	}
+	// when the data descriptor flag is set, the local signature and sizes are zeroed out; all-zero values are
+	// also tolerated when the flag is clear because some tools produce them (streaming writers predating bit 3)
+	if (!localDirectory.bitFlag.dataDescriptor &&
+		(localDirectory.signature || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
+		(localDirectory.signature != zipEntry.signature ||
+			localDirectory.compressedSize != zipEntry.compressedSize ||
+			localDirectory.uncompressedSize != zipEntry.uncompressedSize)) {
+		throwAmbiguousArchive("mismatched local file header (signature or sizes)");
+	}
+}
+
+function throwAmbiguousArchive(reason) {
+	const error = new Error(ERR_AMBIGUOUS_ARCHIVE);
+	error.reason = reason;
+	throw error;
+}
+
 function getOptionValue(zipReader, options, name) {
 	return options[name] === UNDEFINED_VALUE ? zipReader.options[name] : options[name];
 }
@@ -1005,5 +1123,5 @@ function setUint32(view, offset, value) {
 }
 
 function getDataView(array) {
-	return new DataView(array.buffer);
+	return new DataView(array.buffer, array.byteOffset, array.byteLength);
 }