@zip.js/zip.js 2.8.55 → 2.8.56

package/lib/core/options.js

@@ -141,6 +141,8 @@ export {
 	checkFunctionOption,
 	checkSignalOption,
 	checkPasswordOption,
+	checkInteger,
+	checkIntegerOption,
 	toNumber
 };
 
@@ -164,6 +166,18 @@ function checkPasswordOption(password, rawPassword) {
 	}
 }
 
+function checkInteger(value, maxValue, errorMessage) {
+	if (!Number.isInteger(value) || value < 0 || value > maxValue) {
+		throw new Error(errorMessage);
+	}
+}
+
+function checkIntegerOption(value, maxValue, errorMessage) {
+	if (value !== UNDEFINED_VALUE) {
+		checkInteger(value, maxValue, errorMessage);
+	}
+}
+
 function toNumber(value) {
 	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
 }

package/lib/core/zip-reader.js

@@ -544,8 +544,15 @@ class ZipReader {
 			yield entry;
 		}
 		let offsetAfterSignature = offset;
-		const digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
+		let digitalSignature = readDigitalSignature(directoryArray.subarray(offset)) ||
 			(decryptedDirectory ? readDigitalSignature(dataAfterEncryptedDirectory) : UNDEFINED_VALUE);
+		if (!digitalSignature && !decryptedDirectory) {
+			const signatureRecordOffset = directoryDataOffset + offset;
+			const signatureRecordLength = Math.min(centralDirectoryEndOffset - signatureRecordOffset, 6 + MAX_16_BITS);
+			if (signatureRecordLength >= 6) {
+				digitalSignature = readDigitalSignature(await readUint8Array(reader, signatureRecordOffset, signatureRecordLength));
+			}
+		}
 		if (digitalSignature) {
 			zipReader.digitalSignature = digitalSignature;
 			offsetAfterSignature = offset + 6 + digitalSignature.length;

package/lib/core/zip-writer.js

@@ -235,6 +235,8 @@ import {
 	checkFunctionOption,
 	checkSignalOption,
 	checkPasswordOption,
+	checkInteger,
+	checkIntegerOption,
 	toNumber
 } from "./options.js";
 
@@ -276,6 +278,8 @@ const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
+const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
+const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
 const VENDOR_VERSION_AE_1 = 1;
 const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 const UNIX_EXTRA_FIELD_TYPE = "unix";
@@ -322,16 +326,14 @@ class ZipWriter {
 		await zipReader.close();
 		await initStream(this.writer);
 		const { directoryOffset } = zipReader;
-		let splitZipSignatureLength = 0;
 		if (this.addSplitZipSignature) {
 			delete this.addSplitZipSignature;
 			if (!await startsWithSplitZipSignature(reader)) {
 				await writeData(this.writer, getSplitZipSignatureArray());
-				splitZipSignatureLength = SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
-				this.offset += splitZipSignatureLength;
+				this.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 			}
 		}
-		const entryPositions = await copyZipData(this, reader, entries, directoryOffset, splitZipSignatureLength);
+		const entryPositions = await copyZipData(this, reader, entries, directoryOffset);
 		this.filenames = new Set(entries.map(entry => entry.filename));
 		this.fileEntries = new Map(entries.map(entry => {
 			const {
@@ -611,7 +613,8 @@ async function addFile(zipWriter, name, reader, options) {
 			signature: options[PROPERTY_NAME_SIGNATURE],
 			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 			offset: zipWriter.offset - diskOffset,
-			diskNumberStart: diskNumber
+			diskNumberStart: diskNumber,
+			[OPTION_USDZ]: zipWriter.options[OPTION_USDZ]
 		});
 		const headerInfo = getHeaderInfo(options);
 		const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -643,15 +646,9 @@ function resolveAttributes(zipWriter, name, options) {
 	let setuid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETUID);
 	let setgid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETGID);
 	let sticky = getOptionValue(zipWriter, options, PROPERTY_NAME_STICKY);
-	if (uid !== UNDEFINED_VALUE && (!Number.isInteger(uid) || uid < 0 || uid > MAX_32_BITS)) {
-		throw new Error(ERR_INVALID_UID);
-	}
-	if (gid !== UNDEFINED_VALUE && (!Number.isInteger(gid) || gid < 0 || gid > MAX_32_BITS)) {
-		throw new Error(ERR_INVALID_GID);
-	}
-	if (unixMode !== UNDEFINED_VALUE && (!Number.isInteger(unixMode) || unixMode < 0 || unixMode > MAX_16_BITS)) {
-		throw new Error(ERR_INVALID_UNIX_MODE);
-	}
+	checkIntegerOption(uid, MAX_32_BITS, ERR_INVALID_UID);
+	checkIntegerOption(gid, MAX_32_BITS, ERR_INVALID_GID);
+	checkIntegerOption(unixMode, MAX_16_BITS, ERR_INVALID_UNIX_MODE);
 	if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 		throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 	}
@@ -673,9 +670,7 @@ function resolveAttributes(zipWriter, name, options) {
 		msDosCompatible = true;
 		versionMadeBy = (versionMadeBy & MAX_8_BITS);
 	}
-	if (msdosAttributesRaw !== UNDEFINED_VALUE && (!Number.isInteger(msdosAttributesRaw) || msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
-		throw new Error(ERR_INVALID_MSDOS_ATTRIBUTES);
-	}
+	checkIntegerOption(msdosAttributesRaw, MAX_8_BITS, ERR_INVALID_MSDOS_ATTRIBUTES);
 	if (msdosAttributes && (typeof msdosAttributes !== OBJECT_TYPE || Array.isArray(msdosAttributes))) {
 		throw new Error(ERR_INVALID_MSDOS_DATA);
 	}
@@ -815,9 +810,7 @@ function resolveMetadata(zipWriter, name, options) {
 		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 	}
 	let level = getNumberOptionValue(zipWriter, options, OPTION_LEVEL);
-	if (level !== UNDEFINED_VALUE && (!Number.isInteger(level) || level < 0 || level > MAX_LEVEL)) {
-		throw new Error(ERR_INVALID_LEVEL);
-	}
+	checkIntegerOption(level, MAX_LEVEL, ERR_INVALID_LEVEL);
 	if (zipWriter.options[OPTION_USDZ]) {
 		if (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) {
 			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_USDZ);
@@ -895,9 +888,7 @@ function serializeExtraField(extraField) {
 	let extraFieldSize = 0;
 	let offset = 0;
 	extraField.forEach((data, type) => {
-		if (!Number.isInteger(type) || type < 0 || type > MAX_16_BITS) {
-			throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
-		}
+		checkInteger(type, MAX_16_BITS, ERR_INVALID_EXTRAFIELD_TYPE);
 		if (!(data instanceof Uint8Array)) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA_TYPE);
 		}
@@ -1012,7 +1003,9 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	const usdz = writerOptions[OPTION_USDZ];
 	const files = new Map();
 	let layoutDependsOnWriteOrder = Boolean(usdz);
-	let offset = 0;
+	const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
+	let offset = initialOffset;
+	let minimumEntrySize = INFINITY_VALUE;
 	for (const entry of entries) {
 		let { name } = entry;
 		const { size } = entry;
@@ -1036,7 +1029,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
-		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes);
+		const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes, { [OPTION_USDZ]: usdz });
 		const headerInfo = getHeaderInfo(entryOptions);
 		const dataDescriptorInfo = getDataDescriptorInfo(entryOptions);
 		const entryInfo = {
@@ -1047,15 +1040,17 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			appendExtraFieldUSDZ(entryInfo, offset);
 		}
 		const compressedSize = hasContent ? maximumCompressedSize : 0;
-		if (offset >= MAX_32_BITS) {
-			layoutDependsOnWriteOrder = true;
-		}
 		files.set(name, Object.assign({}, entryOptions, headerInfo, {
 			offset,
 			diskNumberStart: 0,
 			compressedSize
 		}));
-		offset += entryInfo.metadataSize + compressedSize;
+		const entrySize = entryInfo.metadataSize + compressedSize;
+		minimumEntrySize = Math.min(minimumEntrySize, entrySize);
+		offset += entrySize;
+	}
+	if (files.size && offset - minimumEntrySize >= MAX_32_BITS) {
+		layoutDependsOnWriteOrder = true;
 	}
 	if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
@@ -1069,7 +1064,7 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 			zip64 = true;
 		}
 	}
-	return offset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+	return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 }
 
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
@@ -1566,12 +1561,13 @@ function getHeaderInfo(options) {
 		if (passThrough && crc32 !== UNDEFINED_VALUE) {
 			rawExtraFieldAES[EXTRAFIELD_OFFSET_AES_VENDOR_VERSION] = VENDOR_VERSION_AE_1;
 		}
-		rawExtraFieldAES[9] = compressionMethod;
+		setUint16(getDataView(rawExtraFieldAES), EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD, compressionMethod);
 		compressionMethod = COMPRESSION_METHOD_AES;
 	}
 	const localExtraFieldZip64Length = writeLocalExtraFieldZip64 ? getLength(rawLocalExtraFieldZip64) : 0;
 	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawLocalExtraField);
-	if (extraFieldLength > MAX_16_BITS) {
+	const maximumUsdzExtraFieldLength = options[OPTION_USDZ] ? EXTRAFIELD_USDZ_MAX_LENGTH : 0;
+	if (extraFieldLength + maximumUsdzExtraFieldLength > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 	}
 	const dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
@@ -1972,7 +1968,11 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 		signatureRecord.writeUint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
 		signatureRecord.writeUint16(signatureDataLength);
 		signatureRecord.writeBytes(signatureData);
-		await writeData(zipWriter.writer, signatureRecord.array);
+		const { writer } = zipWriter;
+		if (exceedsAvailableSize(writer, getLength(signatureRecord.array))) {
+			await writer.closeDisk();
+		}
+		await writeData(writer, signatureRecord.array);
 		return 6 + signatureDataLength;
 	}
 	return 0;
@@ -2083,7 +2083,7 @@ async function startsWithSplitZipSignature(reader) {
 	return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 }
 
-async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZipSignatureLength) {
+async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 	const { writer } = zipWriter;
 	const entryPositions = new Map();
 	if (writer.closeDisk) {
@@ -2104,9 +2104,10 @@ async function copyZipData(zipWriter, reader, entries, directoryOffset, splitZip
 		}
 		await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
 	} else {
+		const baseOffset = zipWriter.offset;
 		await copyData(zipWriter, reader, 0, directoryOffset);
 		entries.forEach(entry => entryPositions.set(entry, {
-			offset: splitZipSignatureLength + getSourceOffset(reader, entry),
+			offset: baseOffset + getSourceOffset(reader, entry),
 			diskNumberStart: 0
 		}));
 	}

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.8.55",
+  "version": "2.8.56",
   "type": "module",
   "keywords": [
     "zip",