@zip.js/zip.js 2.17.0 → 2.18.1

package/deno.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zip-js/zip-js",
-	"version": "2.17.0",
+	"version": "2.18.1",
 	"exports": {
 		".": "./index.js",
 		"./external": "./lib/zip-fs-external.js",

package/dist/zip-core-external.js

@@ -3280,8 +3280,13 @@ function getResponseError(errorData, errorValue) {
 			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) {
@@ -4853,7 +4858,7 @@ const PARENT_DIRECTORY_REGEXP = /(^|[\\/])\.\.([\\/]|$)/;
 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],
@@ -5507,12 +5512,12 @@ class ZipEntry {
 			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);
@@ -5752,8 +5757,16 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	});
 	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) {
@@ -5766,10 +5779,13 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		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);
@@ -5812,20 +5828,35 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	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) {
@@ -6007,32 +6038,27 @@ async function detectOverlappingEntry({
 }) {
 	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 = {
@@ -6097,18 +6123,31 @@ function mergeRanges(sortedRanges, pendingRanges) {
 	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) {
@@ -8931,7 +8970,7 @@ function formatSupported(StreamClass, format) {
  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.