@zip.js/zip.js 2.8.57 → 2.8.59

package/lib/core/zip-reader.js

@@ -68,6 +68,7 @@ import {
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_STRONG_ENCRYPTION,
+	BITFLAG_COMPRESSED_PATCHED_DATA,
 	BITFLAG_MASKED_LOCAL_HEADERS,
 	BITFLAG_LEVEL,
 	BITFLAG_DATA_DESCRIPTOR,
@@ -93,7 +94,8 @@ import {
 	FILE_ATTR_UNIX_SETGID_MASK,
 	FILE_ATTR_UNIX_STICKY_MASK,
 	NUMBER_TYPE,
-	EMPTY_UINT8_ARRAY
+	EMPTY_UINT8_ARRAY,
+	MIN_DATE
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
 import { getRegisteredCodec } from "./codec-registry.js";
@@ -195,6 +197,21 @@ const ERR_INVALID_STRICTNESS = "Invalid strictness (must be 'strict', 'balanced'
 const ERR_INVALID_FILENAME_VALIDATION = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
 const ERR_INVALID_MAX_APPENDED_DATA_SIZE = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
 const ERR_UNSUPPORTED_UINT64 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
+const WARNING_UNSORTED_CENTRAL_DIRECTORY = "unsorted central directory";
+const WARNING_UNKNOWN_VERSION = "unknown version needed to extract";
+const WARNING_COMPRESSED_PATCHED_DATA = "compressed patched data";
+const WARNING_MALFORMED_EXTRA_FIELD = "malformed extra field";
+const WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA = "unknown zip64 extensible data";
+const WARNING_WRAPPED_ENTRIES_COUNT = "wrapped entries count";
+const WARNING_APPENDED_DATA = "appended data";
+const WARNING_PREPENDED_DATA = "prepended data";
+const WARNING_TRAILING_CENTRAL_DIRECTORY_DATA = "trailing central directory data";
+const WARNING_DUPLICATE_FILENAME = "duplicate filename";
+const WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY = "mismatched zip64 end of central directory record";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG = "mismatched local file header (general purpose bit flag)";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD = "mismatched local file header (compression method)";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES = "mismatched local file header (crc32 or sizes)";
+const MAX_KNOWN_VERSION = 63;
 const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
@@ -245,6 +262,7 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
+		const warnings = zipReader.warnings = [];
 		const strictness = getStrictness(options, zipReader.options);
 		const checkAmbiguity = strictness == STRICTNESS_STRICT;
 		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
@@ -268,8 +286,12 @@ class ZipReader {
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		if (reader.size - appendedDataOffset > maxAppendedDataSize) {
-			throwAmbiguousArchive("appended data");
+		const appendedDataLength = reader.size - appendedDataOffset;
+		if (appendedDataLength > maxAppendedDataSize) {
+			throwAmbiguousArchive(WARNING_APPENDED_DATA);
+		}
+		if (appendedDataLength > 0) {
+			addWarning(warnings, WARNING_APPENDED_DATA);
 		}
 		let lastDiskNumber = getUint16(endOfDirectoryView, 4);
 		const expectedLastDiskNumber = reader.lastDiskNumber || 0;
@@ -323,23 +345,23 @@ class ZipReader {
 				}
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32(endOfDirectoryView, 16);
-				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (diskNumber == MAX_16_BITS) {
 					diskNumber = getUint32(endOfDirectoryView, 20);
-				} else if (checkAmbiguity && diskNumber != getUint32(endOfDirectoryView, 20)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (diskNumber != getUint32(endOfDirectoryView, 20)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (filesLength == MAX_16_BITS) {
 					filesLength = getBigUint64(endOfDirectoryView, 32);
-				} else if (checkAmbiguity && filesLength != getBigUint64(endOfDirectoryView, 32)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (filesLength != getBigUint64(endOfDirectoryView, 32)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (directoryDataLength == MAX_32_BITS) {
 					directoryDataLength = getBigUint64(endOfDirectoryView, 40);
-				} else if (checkAmbiguity && directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				directoryDataOffset = getDiskOffset(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
@@ -408,11 +430,23 @@ class ZipReader {
 			declaredDirectoryDataLength = directoryArray.length;
 			decryptedDirectory = true;
 		}
+		if (directoryEncryptionInfo && !decryptedDirectory &&
+			(directoryArray.length < 4 || getUint32(directoryView, 0) == CENTRAL_FILE_HEADER_SIGNATURE)) {
+			addWarning(warnings, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA);
+		}
 		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;
+		const filenames = new Set();
 		let duplicateFilename;
+		let previousEntryPosition = -1;
+		const recoverWrappedFilesLength = !checkAmbiguity && !zip64EndOfDirectory;
+		if (!filesLength && recoverWrappedFilesLength) {
+			filesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+			if (filesLength) {
+				addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
+			}
+		}
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry(reader, zipReader.options);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
@@ -490,15 +524,26 @@ class ZipReader {
 				filename,
 				comment
 			});
-			readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			if (readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6)) {
+				addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
+			}
 			fileEntry.offset += prependedDataLength;
-			startOffset = Math.min(getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset, startOffset);
-			if (checkAmbiguity) {
-				if (filenames.has(fileEntry.filename)) {
-					duplicateFilename = true;
-				}
-				filenames.add(fileEntry.filename);
+			const entryPosition = getDiskOffset(reader, fileEntry.diskNumberStart) + fileEntry.offset;
+			startOffset = Math.min(entryPosition, startOffset);
+			if (entryPosition < previousEntryPosition) {
+				addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+			}
+			previousEntryPosition = entryPosition;
+			if ((fileEntry.version & MAX_8_BITS) > MAX_KNOWN_VERSION) {
+				addWarning(warnings, WARNING_UNKNOWN_VERSION, filename);
+			}
+			if ((fileEntry.rawBitFlag & BITFLAG_COMPRESSED_PATCHED_DATA) == BITFLAG_COMPRESSED_PATCHED_DATA) {
+				addWarning(warnings, WARNING_COMPRESSED_PATCHED_DATA, filename);
+			}
+			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;
@@ -522,7 +567,7 @@ class ZipReader {
 				internalFileAttribute: fileEntry.internalFileAttributes,
 				externalFileAttribute: fileEntry.externalFileAttributes,
 				executable,
-				directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || (fileEntry.filename.endsWith(DIRECTORY_SIGNATURE) && !fileEntry.uncompressedSize),
+				directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE),
 				zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
 			});
 			const entry = new Entry(fileEntry);
@@ -535,6 +580,13 @@ class ZipReader {
 				return arrayBufferPromise;
 			};
 			offset = endOffset;
+			if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
+				const wrappedFilesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+				if (wrappedFilesLength) {
+					filesLength += wrappedFilesLength;
+					addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
+				}
+			}
 			const { onprogress } = options;
 			if (onprogress) {
 				try {
@@ -559,18 +611,22 @@ class ZipReader {
 			zipReader.digitalSignature = digitalSignature;
 			offsetAfterSignature = offset + 6 + digitalSignature.length;
 		}
-		if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
-			throwAmbiguousArchive("trailing central directory data");
+		if ((offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) ||
+			(!decryptedDirectory && offset != directoryDataLength && offsetAfterSignature != directoryDataLength)) {
+			reportAmbiguity(checkAmbiguity, warnings, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA);
 		}
 		if (duplicateFilename) {
-			throwAmbiguousArchive("duplicate filename");
+			reportAmbiguity(checkAmbiguity, warnings, WARNING_DUPLICATE_FILENAME);
 		}
 		const extractPrependedData = getOptionValue(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength &&
 			startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
 		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > splitZipSignatureLength))) {
-			throwAmbiguousArchive("prepended data");
+			throwAmbiguousArchive(WARNING_PREPENDED_DATA);
+		}
+		if (prependedDataLength || (filesLength && startOffset > SPLIT_ZIP_FILE_SIGNATURE_LENGTH)) {
+			addWarning(warnings, WARNING_PREPENDED_DATA);
 		}
 		if (extractPrependedData) {
 			zipReader.prependedData = startOffset > splitZipSignatureLength ?
@@ -640,8 +696,31 @@ class ZipReaderStream {
 	}
 }
 
+async function isZipFile(reader, options = {}) {
+	reader = new GenericReader(reader);
+	await initStream(reader);
+	if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+		reader = new BlobReader(await streamToBlob(reader.readable));
+		await initStream(reader);
+	}
+	if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
+		return false;
+	}
+	const strictness = getStrictness(options, {});
+	const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+	const maxAppendedDataSize = getMaxAppendedDataSize(options[OPTION_MAX_APPENDED_DATA_SIZE], strictness);
+	const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
+	if (!endOfDirectoryInfo || (strictness == STRICTNESS_STRICT && endOfDirectoryReachingEndCount > 1)) {
+		return false;
+	}
+	const commentLength = getUint16(getDataView(endOfDirectoryInfo), 20);
+	const appendedDataOffset = endOfDirectoryInfo.offset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+	return reader.size - appendedDataOffset <= maxAppendedDataSize;
+}
+
 export {
 	ZipReader,
+	isZipFile,
 	ZipReaderStream,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
@@ -668,7 +747,21 @@ export {
 	ERR_INVALID_FILENAME_VALIDATION,
 	ERR_INVALID_MAX_APPENDED_DATA_SIZE,
 	ERR_UNSUPPORTED_UINT64,
-	ERR_WORKER_STARTUP_TIMEOUT
+	ERR_WORKER_STARTUP_TIMEOUT,
+	WARNING_UNSORTED_CENTRAL_DIRECTORY,
+	WARNING_UNKNOWN_VERSION,
+	WARNING_COMPRESSED_PATCHED_DATA,
+	WARNING_MALFORMED_EXTRA_FIELD,
+	WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA,
+	WARNING_WRAPPED_ENTRIES_COUNT,
+	WARNING_APPENDED_DATA,
+	WARNING_PREPENDED_DATA,
+	WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
+	WARNING_DUPLICATE_FILENAME,
+	WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES
 };
 
 class ZipEntry {
@@ -702,6 +795,7 @@ class ZipEntry {
 			dataDescriptor
 		} = bitFlag;
 		const localDirectory = fileEntry.localDirectory = {};
+		const warnings = fileEntry.warnings = [];
 		const localHeaderOffset = getDiskOffset(reader, diskNumberStart) + offset;
 		const dataArray = await readUint8Array(reader, localHeaderOffset, HEADER_SIZE);
 		const dataView = getDataView(dataArray);
@@ -724,6 +818,7 @@ class ZipEntry {
 			extraFieldLength,
 			filenameLength
 		} = localDirectory;
+		const dataOffset = localDirectory.dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 		const checkLocalDirectoryOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
 		const entryStrictness = getStrictness(options, zipEntry.options);
 		const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
@@ -741,10 +836,10 @@ class ZipEntry {
 		if (checkLocalFilename) {
 			localDirectory.rawFilename = rawLocalFilename;
 		}
-		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		if (checkLocalDirectory) {
-			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
+		if (readCommonFooter(zipEntry, localDirectory, dataView, 4, true)) {
+			addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD);
 		}
+		validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 		if (lastAccessDate) {
 			fileEntry.lastAccessDate = lastAccessDate;
@@ -777,7 +872,6 @@ class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 		if (dataOffset + compressedSize > reader.size) {
 			throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
 		}
@@ -897,6 +991,16 @@ function detectEncryptedCentralDirectory(directoryView) {
 	return false;
 }
 
+function getWrappedFilesLength(directoryView, directoryArray, offset) {
+	let wrappedFilesLength = 0;
+	while (offset + CENTRAL_FILE_HEADER_LENGTH <= directoryArray.length && getUint32(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE) {
+		offset += CENTRAL_FILE_HEADER_LENGTH +
+			getUint16(directoryView, offset + 28) + getUint16(directoryView, offset + 30) + getUint16(directoryView, offset + 32);
+		wrappedFilesLength++;
+	}
+	return wrappedFilesLength % (MAX_16_BITS + 1) ? 0 : wrappedFilesLength;
+}
+
 function readDigitalSignature(signatureRecordArray) {
 	if (signatureRecordArray.length >= 6) {
 		const signatureRecordView = getDataView(signatureRecordArray);
@@ -961,6 +1065,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	const extraField = directory.extraField = new Map();
 	const rawExtraFieldView = getDataView(rawExtraField);
 	let offsetExtraField = 0;
+	let malformedExtraField = false;
 	try {
 		while (offsetExtraField < rawExtraField.length) {
 			const type = getUint16(rawExtraFieldView, offsetExtraField);
@@ -972,7 +1077,10 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 			offsetExtraField += 4 + size;
 		}
 	} catch {
-		// ignored
+		malformedExtraField = true;
+	}
+	if (offsetExtraField > rawExtraField.length) {
+		malformedExtraField = true;
 	}
 	const compressionMethod = getUint16(dataView, offset + 4);
 	Object.assign(directory, {
@@ -1040,6 +1148,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	if (extraFieldUSDZ) {
 		directory.extraFieldUSDZ = extraFieldUSDZ;
 	}
+	return malformedExtraField;
 }
 
 function readExtraFieldZip64(extraFieldZip64, directory) {
@@ -1069,10 +1178,11 @@ function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName,
 	const computedCrc32View = getDataView(new Uint8Array(4));
 	computedCrc32View.setUint32(0, computedCrc32.get(), true);
 	const nameCrc32 = getUint32(extraFieldView, 1);
+	const version = getUint8(extraFieldView, 0);
 	Object.assign(extraFieldUnicode, {
-		version: getUint8(extraFieldView, 0),
+		version,
 		[propertyName]: decodeText(extraFieldUnicode.data.subarray(5)),
-		valid: !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32(computedCrc32View, 0)
+		valid: version == 1 && !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32(computedCrc32View, 0)
 	});
 	if (extraFieldUnicode.valid) {
 		directory[propertyName] = extraFieldUnicode[propertyName];
@@ -1500,27 +1610,46 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	return UNDEFINED_VALUE;
 }
 
-function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, warnings) {
 	const { rawFilename } = zipEntry;
+	const reject = !warnings;
 	const maskedLocalDirectory = zipEntry.decryptedDirectory &&
 		(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
 	if (checkLocalFilename && !maskedLocalDirectory &&
 		(rawLocalFilename.length != rawFilename.length ||
 			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
-		throwAmbiguousArchive("mismatched local file header (filename)");
+		reportAmbiguity(reject, warnings, "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)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG);
 	}
 	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
-		throwAmbiguousArchive("mismatched local file header (compression method)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD);
 	}
 	if (!localDirectory.bitFlag.dataDescriptor && !maskedLocalDirectory &&
 		(localDirectory.crc32 || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 		(localDirectory.crc32 != zipEntry.crc32 ||
 			localDirectory.compressedSize != zipEntry.compressedSize ||
 			localDirectory.uncompressedSize != zipEntry.uncompressedSize)) {
-		throwAmbiguousArchive("mismatched local file header (crc32 or sizes)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES);
+	}
+}
+
+function reportAmbiguity(reject, warnings, reason) {
+	if (reject) {
+		throwAmbiguousArchive(reason);
+	} else {
+		addWarning(warnings, reason);
+	}
+}
+
+function addWarning(warnings, reason, filename) {
+	if (!warnings.some(warning => warning.reason == reason)) {
+		const warning = { reason };
+		if (filename !== UNDEFINED_VALUE) {
+			warning.filename = filename;
+		}
+		warnings.push(warning);
 	}
 }
 
@@ -1541,7 +1670,8 @@ function getFunctionOptionValue(zipReader, options, name) {
 
 function getDate(timeRaw) {
 	const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & MAX_16_BITS;
-	return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
+	const result = new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
+	return result < MIN_DATE ? MIN_DATE : result;
 }
 
 function getDateNTFS(timeRaw) {