@zip.js/zip.js 2.17.0 → 2.18.1

package/dist/zip-fs-core.js

@@ -3245,8 +3245,13 @@
 				if (codecImportFailed) {
 					responseError.codecImportFailed = true;
 				}
-				if (cause && !isErrorObject(responseError.cause)) {
-					responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+				if (cause) {
+					if (!isErrorObject(responseError.cause)) {
+						responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+					}
+					if (cause.code !== UNDEFINED_VALUE && responseError.cause.code !== cause.code) {
+						responseError.cause.code = cause.code;
+					}
 				}
 				if (errorValue) {
 					if (responseError.name !== name) {
@@ -4838,7 +4843,7 @@
 	const CHARSET_UTF8 = "utf-8";
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 	const CHARSET_CP437 = "cp437";
-	const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
+	const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_STRONG_ENCRYPTION | BITFLAG_LANG_ENCODING_FLAG;
 	const VENDOR_VERSION_AE_1$1 = 1;
 	const ZIP64_PROPERTIES = [
 		[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
@@ -5492,12 +5497,12 @@
 				fileEntry.gid = gid;
 			}
 			const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
-			const encrypted = zipEntry.encrypted && localDirectory.encrypted && (!passThroughEncryption || checkPasswordOnly);
+			const encrypted = zipEntry.encrypted && (!passThroughEncryption || checkPasswordOnly);
 			const zipCrypto = encrypted && !extraFieldAES;
 			if (!passThroughEncryption) {
 				fileEntry.zipCrypto = zipCrypto;
 			}
-			if (encrypted && (localDirectory.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
+			if (encrypted && (zipEntry.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
 				throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 			}
 			const registeredCodec = passThroughCompression ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
@@ -5737,8 +5742,16 @@
 		});
 		const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 		if (extraFieldZip64) {
-			readExtraFieldZip64(extraFieldZip64, directory);
+			if (!readExtraFieldZip64(extraFieldZip64, directory, localDirectory)) {
+				malformedExtraField = true;
+			}
 			directory.extraFieldZip64 = extraFieldZip64;
+		} else if (ZIP64_PROPERTIES.some(([propertyName, max]) => directory[propertyName] == max)) {
+			if (localDirectory) {
+				malformedExtraField = true;
+			} else {
+				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+			}
 		}
 		const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
 		if (extraFieldUnicodePath) {
@@ -5751,10 +5764,13 @@
 			directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
 		}
 		const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
-		if (extraFieldAES && extraFieldAES.data.length >= 7) {
+		if (extraFieldAES && (compressionMethod == COMPRESSION_METHOD_AES || directory.encrypted) && extraFieldAES.data.length >= 7) {
 			readExtraFieldAES(extraFieldAES, directory, compressionMethod);
 			directory.extraFieldAES = extraFieldAES;
 		} else {
+			if (extraFieldAES) {
+				malformedExtraField = true;
+			}
 			directory.compressionMethod = compressionMethod;
 		}
 		const extraFieldPkwareUnix = extraField.get(EXTRAFIELD_TYPE_PKWARE_UNIX);
@@ -5797,20 +5813,35 @@
 		return malformedExtraField;
 	}
 
-	function readExtraFieldZip64(extraFieldZip64, directory) {
+	function readExtraFieldZip64(extraFieldZip64, directory, localDirectory) {
 		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) {
+			if (localDirectory) {
+				return false;
+			}
 			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
 		}
-		for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
-			const [propertyName, max] = missingProperties[indexMissingProperty];
-			const extraction = ZIP64_EXTRACTION[max];
-			directory[propertyName] = extraFieldZip64[propertyName] = extraction.getValue(extraFieldView, offset);
-			offset += extraction.bytes;
+		const values = [];
+		try {
+			for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
+				const [, max] = missingProperties[indexMissingProperty];
+				const extraction = ZIP64_EXTRACTION[max];
+				values.push(extraction.getValue(extraFieldView, offset));
+				offset += extraction.bytes;
+			}
+		} catch (error) {
+			if (localDirectory) {
+				return false;
+			}
+			throw error;
 		}
+		missingProperties.forEach(([propertyName], indexMissingProperty) => {
+			directory[propertyName] = extraFieldZip64[propertyName] = values[indexMissingProperty];
+		});
+		return true;
 	}
 
 	function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
@@ -5992,32 +6023,27 @@
 	}) {
 		let dataDescriptorLength = 0;
 		if (dataDescriptor) {
-			if (extraFieldZip64) {
-				dataDescriptorLength = DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH;
-			} else {
-				dataDescriptorLength = DATA_DESCRIPTOR_RECORD_LENGTH;
-			}
-		}
-		if (dataDescriptorLength) {
-			const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
+			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);
-			let signature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-				getUint32$1(dataDescriptorView, 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
-			if (signature) {
-				const signedDataDescriptor = readDataDescriptor(dataDescriptorView, DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, extraFieldZip64);
-				const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || signedDataDescriptor.crc32 == crc32;
-				if (matchCrc32 &&
-					signedDataDescriptor.compressedSize == compressedSize &&
-					signedDataDescriptor.uncompressedSize == uncompressedSize) {
-					dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
-				} else {
-					signature = false;
+			const ignoreCrc32 = fileEntry.encrypted && !fileEntry.zipCrypto;
+			let localDataDescriptor;
+			for (const [zip64Layout, signature] of [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]) {
+				const candidate = readDataDescriptor(dataDescriptorView, zip64Layout, signature);
+				if (candidate && (ignoreCrc32 || candidate.crc32 == crc32) &&
+					candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize) {
+					localDataDescriptor = candidate;
+					break;
 				}
 			}
-			if (dataDescriptorArray.length >= dataDescriptorLength) {
-				const localDataDescriptor = readDataDescriptor(dataDescriptorView, signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0, extraFieldZip64);
-				localDataDescriptor.signature = signature;
+			if (!localDataDescriptor) {
+				localDataDescriptor = readDataDescriptor(dataDescriptorView, zip64, false);
+			}
+			if (localDataDescriptor) {
 				fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+				dataDescriptorLength = getDataDescriptorLength(localDataDescriptor.zip64, localDataDescriptor.signature);
+			} else {
+				dataDescriptorLength = getDataDescriptorLength(zip64, false);
 			}
 		}
 		const range = {
@@ -6082,18 +6108,31 @@
 		return mergedRanges;
 	}
 
-	function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
+	function readDataDescriptor(dataDescriptorView, zip64, signature) {
+		const offset = signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0;
+		if (dataDescriptorView.byteLength < getDataDescriptorLength(zip64, signature) ||
+			(signature && getUint32$1(dataDescriptorView, 0) != DATA_DESCRIPTOR_RECORD_SIGNATURE)) {
+			return UNDEFINED_VALUE;
+		}
 		const crc32 = getUint32$1(dataDescriptorView, offset);
 		let compressedSize;
 		let uncompressedSize;
-		if (extraFieldZip64) {
-			compressedSize = getBigUint64(dataDescriptorView, offset + 4);
-			uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
-		} else {
-			compressedSize = getUint32$1(dataDescriptorView, offset + 4);
-			uncompressedSize = getUint32$1(dataDescriptorView, offset + 8);
+		try {
+			if (zip64) {
+				compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+				uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+			} else {
+				compressedSize = getUint32$1(dataDescriptorView, offset + 4);
+				uncompressedSize = getUint32$1(dataDescriptorView, offset + 8);
+			}
+		} catch {
+			return UNDEFINED_VALUE;
 		}
-		return { crc32, compressedSize, uncompressedSize };
+		return { signature, zip64, crc32, compressedSize, uncompressedSize };
+	}
+
+	function getDataDescriptorLength(zip64, signature) {
+		return (zip64 ? DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH : DATA_DESCRIPTOR_RECORD_LENGTH) + (signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0);
 	}
 
 	function getDiskOffset$1(reader, diskNumber) {
@@ -9014,7 +9053,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.17.0";
+	const VERSION = "2.18.1";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.