@zip.js/zip.js 2.8.46 → 2.8.48

package/lib/core/zip-reader.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Response, WritableStream, ReadableStream, TransformStream */
+/* global WritableStream, ReadableStream, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -43,6 +43,7 @@ import {
 	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	ARCHIVE_EXTRA_DATA_SIGNATURE,
+	DIGITAL_SIGNATURE_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
@@ -100,7 +101,8 @@ import {
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
 	ERR_INVALID_COMPRESSED_DATA,
-	ERR_ABORT_CHECK_PASSWORD
+	ERR_ABORT_CHECK_PASSWORD,
+	ERR_WORKER_STARTUP_TIMEOUT
 } from "./codec-pool.js";
 import {
 	initStream,
@@ -111,7 +113,7 @@ import {
 } from "./io.js";
 import { decodeText } from "./util/decode-text.js";
 import { getDataView } from "./util/array.js";
-import { toCompatibleReadable } from "./util/compatible-streams.js";
+import { toCompatibleReadable, streamToBlob } from "./util/compatible-streams.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import {
 	PROPERTY_NAME_RAW_FILENAME,
@@ -149,6 +151,7 @@ import {
 	OPTION_CHECK_AUTHENTICATION_CODE,
 	OPTION_STRICTNESS,
 	OPTION_MAX_APPENDED_DATA_SIZE,
+	OPTION_DECRYPT_CENTRAL_DIRECTORY,
 	STRICTNESS_STRICT,
 	STRICTNESS_BALANCED,
 	STRICTNESS_TOLERANT,
@@ -210,7 +213,7 @@ class ZipReader {
 		const { config } = zipReader;
 		await initStream(reader);
 		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
-			reader = new BlobReader(await new Response(reader.readable).blob());
+			reader = new BlobReader(await streamToBlob(reader.readable));
 			await initStream(reader);
 		}
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
@@ -250,6 +253,7 @@ class ZipReader {
 		let startOffset;
 		let zip64EndOfDirectory;
 		let zip64EndOfDirectoryVersion2;
+		let directoryEncryptionInfo;
 		const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
 		if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
 			directoryDataOffset += getDiskOffset(reader, diskNumber);
@@ -280,6 +284,15 @@ class ZipReader {
 				}
 				zip64EndOfDirectory = true;
 				zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
+				if (zip64EndOfDirectoryVersion2) {
+					const extensibleDataLength = Math.min(
+						Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+						reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+					if (extensibleDataLength > 0) {
+						const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
+						directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
+					}
+				}
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32(endOfDirectoryView, 16);
 				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
@@ -303,7 +316,7 @@ class ZipReader {
 				directoryDataOffset = getDiskOffset(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
 		}
-		const declaredDirectoryDataLength = directoryDataLength;
+		let 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) {
@@ -351,6 +364,18 @@ class ZipReader {
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
+		zipReader.directoryOffset = directoryDataOffset;
+		zipReader.directoryLength = declaredDirectoryDataLength;
+		const decryptCentralDirectory = getOptionValue(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+		let decryptedDirectory;
+		if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
+			getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
+			(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+			directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+			directoryView = getDataView(directoryArray);
+			declaredDirectoryDataLength = directoryArray.length;
+			decryptedDirectory = true;
+		}
 		startOffset = directoryDataOffset;
 		const filenameEncoding = getOptionValue(zipReader, options, OPTION_FILENAME_ENCODING);
 		const commentEncoding = getOptionValue(zipReader, options, OPTION_COMMENT_ENCODING);
@@ -359,7 +384,7 @@ class ZipReader {
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry(reader, config, zipReader.options);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
-				if (indexFile == 0 && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+				if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
 				}
 				throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
@@ -457,7 +482,7 @@ class ZipReader {
 			entry.arrayBuffer = async options => {
 				const writer = new TransformStream();
 				const [arrayBuffer] = await Promise.all([
-					new Response(writer.readable).arrayBuffer(),
+					streamToBlob(writer.readable).then(blob => blob.arrayBuffer()),
 					fileEntry.getData(writer, entry, zipReader.readRanges, options)]);
 				return arrayBuffer;
 			};
@@ -472,7 +497,15 @@ class ZipReader {
 			}
 			yield entry;
 		}
-		if (checkAmbiguity && offset != declaredDirectoryDataLength) {
+		let offsetAfterSignature = offset;
+		if (offset + 6 <= directoryArray.length && getUint32(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+			const signatureDataLength = getUint16(directoryView, offset + 4);
+			if (offset + 6 + signatureDataLength <= directoryArray.length) {
+				zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
+				offsetAfterSignature = offset + 6 + signatureDataLength;
+			}
+		}
+		if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 			throwAmbiguousArchive("trailing central directory data");
 		}
 		if (duplicateFilename) {
@@ -566,7 +599,8 @@ export {
 	ERR_SPLIT_ZIP_FILE,
 	ERR_OVERLAPPING_ENTRY,
 	ERR_AMBIGUOUS_ARCHIVE,
-	ERR_ENCRYPTED_CENTRAL_DIRECTORY
+	ERR_ENCRYPTED_CENTRAL_DIRECTORY,
+	ERR_WORKER_STARTUP_TIMEOUT
 };
 
 class ZipEntry {
@@ -768,6 +802,25 @@ function detectEncryptedCentralDirectory(directoryView) {
 	return false;
 }
 
+function getDirectoryEncryptionInfo(rawExtensibleData) {
+	const directoryEncryptionInfo = { rawExtensibleData };
+	if (rawExtensibleData.length >= 28) {
+		const extensibleDataView = getDataView(rawExtensibleData);
+		const hashDataLength = getUint16(extensibleDataView, 26);
+		Object.assign(directoryEncryptionInfo, {
+			compressionMethod: getUint16(extensibleDataView, 0),
+			compressedSize: Number(getBigUint64(extensibleDataView, 2)),
+			uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+			encryptionAlgorithm: getUint16(extensibleDataView, 18),
+			bitLength: getUint16(extensibleDataView, 20),
+			flags: getUint16(extensibleDataView, 22),
+			hashAlgorithm: getUint16(extensibleDataView, 24),
+			hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
+		});
+	}
+	return directoryEncryptionInfo;
+}
+
 function readCommonHeader(directory, dataView, offset) {
 	const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
 	const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;

package/lib/core/zip-writer.js

@@ -88,6 +88,7 @@ import {
 	SPLIT_ZIP_FILE_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
+	DIGITAL_SIGNATURE_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
 	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
@@ -146,7 +147,8 @@ import { getRegisteredCodec } from "./codec-registry.js";
 import { supportsDeflate } from "./codec-worker.js";
 import {
 	CODEC_DEFLATE,
-	runWorker
+	runWorker,
+	ERR_UNSUPPORTED_CRYPTO_API
 } from "./codec-pool.js";
 import {
 	initStream,
@@ -209,7 +211,8 @@ import {
 	OPTION_OFFSET,
 	OPTION_USDZ,
 	OPTION_UNIX_EXTRA_FIELD_TYPE,
-	OPTION_LOCAL_EXTRA_FIELD
+	OPTION_LOCAL_EXTRA_FIELD,
+	OPTION_SIGN_CENTRAL_DIRECTORY
 } from "./options.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
@@ -237,6 +240,7 @@ const ERR_INVALID_UNIX_EXTRA_FIELD_TYPE = "Invalid unixExtraFieldType (must be '
 const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldType 'unix' (use 'infozip' for larger ids)";
 const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
+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;
@@ -515,7 +519,16 @@ export {
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_UNDEFINED_READER,
-	ERR_ZIP_NOT_EMPTY
+	ERR_ZIP_NOT_EMPTY,
+	ERR_INVALID_SIGNATURE_DATA,
+	ERR_INVALID_UID,
+	ERR_INVALID_GID,
+	ERR_INVALID_UNIX_MODE,
+	ERR_INVALID_UNIX_EXTRA_FIELD_TYPE,
+	ERR_INVALID_UNIX_ID_SIZE,
+	ERR_INVALID_MSDOS_ATTRIBUTES,
+	ERR_INVALID_MSDOS_DATA,
+	ERR_UNSUPPORTED_CRYPTO_API
 };
 
 async function addFile(zipWriter, name, reader, options) {
@@ -1614,8 +1627,9 @@ function updateLocalHeader({
 
 async function closeFile(zipWriter, comment, options) {
 	const directoryDataLength = createDirectoryRecords(zipWriter.files);
-	const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
+	const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+	const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
 }
 
 function createDirectoryRecords(files) {
@@ -1772,12 +1786,33 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		}
 	}
 	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-	return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
+	return {
+		directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+		directoryArray
+	};
+}
+
+async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
+	const signCentralDirectory = getOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
+	if (signCentralDirectory) {
+		const signatureData = await signCentralDirectory(directoryArray);
+		const signatureDataLength = getLength(signatureData);
+		if (signatureDataLength > MAX_16_BITS) {
+			throw new Error(ERR_INVALID_SIGNATURE_DATA);
+		}
+		const signatureRecord = createRecordWriter(6 + signatureDataLength);
+		signatureRecord.uint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
+		signatureRecord.uint16(signatureDataLength);
+		signatureRecord.bytes(signatureData);
+		await writeData(zipWriter.writer, signatureRecord.array);
+		return 6 + signatureDataLength;
+	}
+	return 0;
 }
 
 async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
-	const { directoryStart } = cdInfo;
+	const { directoryStart, signatureLength } = cdInfo;
 	let { directoryDataLength } = cdInfo;
 	let filesLength = zipWriter.files.size;
 	let diskNumber = directoryStart.diskNumber;
@@ -1816,7 +1851,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		endOfdirectoryRecord.uint64(directoryOffset);
 		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 		endOfdirectoryRecord.uint32(lastDiskNumber);
-		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
+		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
 		endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {

package/lib/zip-core-base.js

@@ -77,5 +77,6 @@ export {
 	createBlobTempStream
 } from "./core/util/blob-temp-stream.js";
 export {
-	createSyncAccessHandleTempStream
+	createSyncAccessHandleTempStream,
+	ERR_UNSUPPORTED_CONTEXT
 } from "./core/util/sync-access-handle-temp-stream.js";

package/lib/zip-core-reader.js

@@ -47,5 +47,6 @@ export {
 	ERR_SPLIT_ZIP_FILE,
 	ERR_OVERLAPPING_ENTRY,
 	ERR_AMBIGUOUS_ARCHIVE,
-	ERR_ENCRYPTED_CENTRAL_DIRECTORY
+	ERR_ENCRYPTED_CENTRAL_DIRECTORY,
+	ERR_WORKER_STARTUP_TIMEOUT
 } from "./core/zip-reader.js";

package/lib/zip-core-writer.js

@@ -41,5 +41,14 @@ export {
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
 	ERR_UNDEFINED_READER,
-	ERR_ZIP_NOT_EMPTY
+	ERR_ZIP_NOT_EMPTY,
+	ERR_INVALID_SIGNATURE_DATA,
+	ERR_INVALID_UID,
+	ERR_INVALID_GID,
+	ERR_INVALID_UNIX_MODE,
+	ERR_INVALID_UNIX_EXTRA_FIELD_TYPE,
+	ERR_INVALID_UNIX_ID_SIZE,
+	ERR_INVALID_MSDOS_ATTRIBUTES,
+	ERR_INVALID_MSDOS_DATA,
+	ERR_UNSUPPORTED_CRYPTO_API
 } from "./core/zip-writer.js";

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.46",
+  "version": "2.8.48",
   "type": "module",
   "keywords": [
     "zip",
@@ -37,6 +37,7 @@
     "lint": "npx eslint . && deno lint",
     "test": "npm run test-node && npm run test-deno && npm run test-bun && npm run test-node-dist && npm run test-deno-dist && npm run test-bun-dist && npm run test-web-streams-polyfill && npm run test-types",
     "test-browsers": "npm run test-chrome && npm run test-firefox && npm run test-webkit",
+    "serve-tests": "http-server -p 8888 -c-1 .",
     "test-all": "npm run lint && npm run test && npm run test-browsers",
     "build": "npx rollup -c",
     "build-dev": "npx rollup -c --environment DEV",