@zip.js/zip.js 2.5.3 → 2.5.4

package/lib/core/codecs/aes-crypto-stream.js

@@ -45,14 +45,19 @@ const SALT_LENGTH = [8, 12, 16];
 const KEY_LENGTH = [16, 24, 32];
 const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
-const CRYPTO_API_SUPPORTED = typeof crypto != "undefined";
-const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != "undefined";
+const UNDEFINED_TYPE = "undefined";
+const FUNCTION_TYPE = "function";
+const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
+const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != UNDEFINED_TYPE;
+const GET_RANDOM_VALUES_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.getRandomValues == FUNCTION_TYPE;
+const IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == FUNCTION_TYPE;
+const DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == FUNCTION_TYPE;
 const codecBytes = codec.bytes;
 const Aes = cipher.aes;
 const CtrGladman = mode.ctrGladman;
 const HmacSha1 = misc.hmacSha1;
 
-class AESDecryptStream extends TransformStream {
+class AESDecryptionStream extends TransformStream {
 
 	constructor(password, signed, strength) {
 		let stream;
@@ -74,7 +79,7 @@ class AESDecryptStream extends TransformStream {
 						aesCrypto.password = null;
 						const preamble = subarray(chunk, 0, SALT_LENGTH[aesCrypto.strength] + 2);
 						await createDecryptionKeys(aesCrypto, preamble, password);
-						aesCrypto.aesCtrGladman = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
+						aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
 						aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
 						chunk = subarray(chunk, SALT_LENGTH[aesCrypto.strength] + 2);
 						aesCrypto.resolveReady();
@@ -93,14 +98,14 @@ class AESDecryptStream extends TransformStream {
 				const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
 				let decryptedChunkArray = new Uint8Array(0);
 				if (chunkToDecrypt.length) {
-					const encryptedChunk = codecBytes.toBits(chunkToDecrypt);
+					const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
 					aesCrypto.hmac.update(encryptedChunk);
-					const decryptedChunk = aesCrypto.aesCtrGladman.update(encryptedChunk);
-					decryptedChunkArray = codecBytes.fromBits(decryptedChunk);
+					const decryptedChunk = aesCrypto.ctr.update(encryptedChunk);
+					decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 				}
 				stream.valid = true;
 				if (aesCrypto.signed) {
-					const signature = subarray(codecBytes.fromBits(aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
+					const signature = subarray(fromBits(codecBytes, aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
 					for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
 						if (signature[indexSignature] != originalSignature[indexSignature]) {
 							stream.valid = false;
@@ -114,7 +119,7 @@ class AESDecryptStream extends TransformStream {
 	}
 }
 
-class AESEncryptStream extends TransformStream {
+class AESEncryptionStream extends TransformStream {
 
 	constructor(password, strength) {
 		let stream;
@@ -135,7 +140,7 @@ class AESEncryptStream extends TransformStream {
 						const password = aesCrypto.password;
 						aesCrypto.password = null;
 						preamble = await createEncryptionKeys(aesCrypto, password);
-						aesCrypto.aesCtrGladman = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
+						aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
 						aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
 						aesCrypto.resolveReady();
 					} else {
@@ -151,11 +156,11 @@ class AESEncryptStream extends TransformStream {
 				await aesCrypto.ready;
 				let encryptedChunkArray = new Uint8Array(0);
 				if (aesCrypto.pending.length) {
-					const encryptedChunk = aesCrypto.aesCtrGladman.update(codecBytes.toBits(aesCrypto.pending));
+					const encryptedChunk = aesCrypto.ctr.update(toBits(codecBytes, aesCrypto.pending));
 					aesCrypto.hmac.update(encryptedChunk);
-					encryptedChunkArray = codecBytes.fromBits(encryptedChunk);
+					encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
 				}
-				stream.signature = codecBytes.fromBits(aesCrypto.hmac.digest()).slice(0, SIGNATURE_LENGTH);
+				stream.signature = fromBits(codecBytes, aesCrypto.hmac.digest()).slice(0, SIGNATURE_LENGTH);
 				controller.enqueue(concat(encryptedChunkArray, stream.signature));
 			}
 		});
@@ -164,8 +169,8 @@ class AESEncryptStream extends TransformStream {
 }
 
 export {
-	AESDecryptStream,
-	AESEncryptStream,
+	AESDecryptionStream,
+	AESEncryptionStream,
 	ERR_INVALID_PASSWORD
 };
 
@@ -177,15 +182,15 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignat
 	}
 	let offset;
 	for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) {
-		const inputChunk = codecBytes.toBits(subarray(input, offset, offset + BLOCK_LENGTH));
+		const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH));
 		if (verifySignature) {
 			aesCrypto.hmac.update(inputChunk);
 		}
-		const outputChunk = aesCrypto.aesCtrGladman.update(inputChunk);
+		const outputChunk = aesCrypto.ctr.update(inputChunk);
 		if (!verifySignature) {
 			aesCrypto.hmac.update(outputChunk);
 		}
-		output.set(codecBytes.fromBits(outputChunk), offset + paddingStart);
+		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
 	}
 	aesCrypto.pending = subarray(input, offset);
 	return output;
@@ -212,14 +217,14 @@ async function createKeys(target, password, salt) {
 	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), basekey, 8 * ((KEY_LENGTH[target.strength] * 2) + 2));
 	const compositeKey = new Uint8Array(derivedBits);
 	target.keys = {
-		key: codecBytes.toBits(subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
-		authentication: codecBytes.toBits(subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
+		key: toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
+		authentication: toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
 		passwordVerification: subarray(compositeKey, KEY_LENGTH[target.strength] * 2)
 	};
 }
 
 function getRandomValues(array) {
-	if (CRYPTO_API_SUPPORTED && typeof crypto.getRandomValues == "function") {
+	if (GET_RANDOM_VALUES_SUPPORTED) {
 		return crypto.getRandomValues(array);
 	} else {
 		return random.getRandomValues(array);
@@ -227,7 +232,7 @@ function getRandomValues(array) {
 }
 
 function importKey(format, password, algorithm, extractable, keyUsages) {
-	if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == "function") {
+	if (IMPORT_KEY_SUPPORTED) {
 		return crypto.subtle.importKey(format, password, algorithm, extractable, keyUsages);
 	} else {
 		return misc.importKey(password);
@@ -235,7 +240,7 @@ function importKey(format, password, algorithm, extractable, keyUsages) {
 }
 
 async function deriveBits(algorithm, baseKey, length) {
-	if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == "function") {
+	if (DERIVE_BITS_SUPPORTED) {
 		return await crypto.subtle.deriveBits(algorithm, baseKey, length);
 	} else {
 		return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
@@ -263,4 +268,11 @@ function expand(inputArray, length) {
 
 function subarray(array, begin, end) {
 	return array.subarray(begin, end);
+}
+
+function fromBits(codecBytes, chunk) {
+	return codecBytes.fromBits(chunk);
+}
+function toBits(codecBytes, chunk) {
+	return codecBytes.toBits(chunk);
 }

package/lib/core/codecs/codec-stream.js

@@ -43,13 +43,13 @@ class CodecStream extends TransformStream {
 			},
 			transform(chunk, controller) {
 				chunk = this.codec.append(chunk);
-				if (chunk) {
+				if (chunk && chunk.length) {
 					controller.enqueue(chunk);
 				}
 			},
 			flush(controller) {
 				const chunk = this.codec.flush();
-				if (chunk) {
+				if (chunk && chunk.length) {
 					controller.enqueue(chunk);
 				}
 			}

package/lib/core/codecs/codec.js

@@ -30,8 +30,8 @@
 // deno-lint-ignore-file no-this-alias
 
 import Crc32Stream from "./crc32-stream.js";
-import { AESEncryptStream, AESDecryptStream, ERR_INVALID_PASSWORD } from "./aes-crypto-stream.js";
-import { ZipCryptoDecryptStream, ZipCryptoEncryptStream } from "./zip-crypto-stream.js";
+import { AESEncryptionStream, AESDecryptionStream, ERR_INVALID_PASSWORD } from "./aes-crypto-stream.js";
+import { ZipCryptoDecryptionStream, ZipCryptoEncryptionStream } from "./zip-crypto-stream.js";
 import CodecStream from "./codec-stream.js";
 
 const CODEC_DEFLATE = "deflate";
@@ -42,6 +42,8 @@ const MESSAGE_START = "start";
 const MESSAGE_PULL = "pull";
 const MESSAGE_DATA = "data";
 const MESSAGE_ABORT = "abort";
+const COMPRESSION_FORMAT = "deflate-raw";
+const UNDEFINED_TYPE = "undefined";
 
 class Inflate {
 
@@ -64,30 +66,22 @@ class Inflate {
 				signed,
 				compressed,
 				zipCrypto,
-				stream: new ReadableStream({
-					async pull(controller) {
-						const { value, done } = await codec.pull();
-						controller.enqueue(value);
-						if (done || codec.aborted) {
-							controller.close();
-						}
-					}
-				})
+				stream: createReadableStream(codec)
 			});
 			if (encrypted) {
 				if (zipCrypto) {
-					codec.stream = codec.stream.pipeThrough(new ZipCryptoDecryptStream(password, passwordVerification));
+					codec.stream = codec.stream.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));
 				} else {
-					codec.decryptStream = new AESDecryptStream(password, signed, encryptionStrength);
+					codec.decryptStream = new AESDecryptionStream(password, signed, encryptionStrength);
 					codec.stream = codec.stream.pipeThrough(codec.decryptStream);
 				}
 			}
 			if (compressed) {
-				if ((useCompressionStream !== undefined && !useCompressionStream) || typeof DecompressionStream == "undefined") {
+				if ((useCompressionStream !== undefined && !useCompressionStream) || typeof DecompressionStream == UNDEFINED_TYPE) {
 					pipeCodecStream();
 				} else {
 					try {
-						codec.stream = codec.stream.pipeThrough(new DecompressionStream("deflate-raw"));
+						codec.stream = codec.stream.pipeThrough(new DecompressionStream(COMPRESSION_FORMAT));
 					} catch (_error) {
 						pipeCodecStream();
 					}
@@ -155,15 +149,7 @@ class Deflate {
 				signed,
 				compressed,
 				zipCrypto,
-				stream: new ReadableStream({
-					async pull(controller) {
-						const { value, done } = await codec.pull();
-						controller.enqueue(value);
-						if (done || codec.aborted) {
-							controller.close();
-						}
-					}
-				})
+				stream: createReadableStream(codec)
 			});
 			if ((!encrypted || zipCrypto) && signed) {
 				const tee = codec.stream.tee();
@@ -171,11 +157,11 @@ class Deflate {
 				codec.crc32Stream = tee[1].pipeThrough(new Crc32Stream({ chunkSize }));
 			}
 			if (compressed) {
-				if ((useCompressionStream !== undefined && !useCompressionStream) || typeof CompressionStream == "undefined") {
+				if ((useCompressionStream !== undefined && !useCompressionStream) || typeof CompressionStream == UNDEFINED_TYPE) {
 					pipeCodecStream();
 				} else {
 					try {
-						codec.stream = codec.stream.pipeThrough(new CompressionStream("deflate-raw"));
+						codec.stream = codec.stream.pipeThrough(new CompressionStream(COMPRESSION_FORMAT));
 					} catch (_error) {
 						pipeCodecStream();
 					}
@@ -183,9 +169,9 @@ class Deflate {
 			}
 			if (encrypted) {
 				if (zipCrypto) {
-					codec.stream = codec.stream.pipeThrough(new ZipCryptoEncryptStream(password, passwordVerification));
+					codec.stream = codec.stream.pipeThrough(new ZipCryptoEncryptionStream(password, passwordVerification));
 				} else {
-					codec.encryptStream = new AESEncryptStream(password, encryptionStrength);
+					codec.encryptStream = new AESEncryptionStream(password, encryptionStrength);
 					codec.stream = codec.stream.pipeThrough(codec.encryptStream);
 				}
 			}
@@ -243,4 +229,18 @@ function createCodec(codecConstructor, options, config) {
 	} else if (options.codecType.startsWith(CODEC_INFLATE)) {
 		return new Inflate(codecConstructor, options, config);
 	}
+}
+
+function createReadableStream(codec) {
+	return new ReadableStream({
+		async pull(controller) {
+			const { value, done } = await codec.pull();
+			if (value) {
+				controller.enqueue(value);
+			}
+			if (done || codec.aborted) {
+				controller.close();
+			}
+		}
+	});
 }

package/lib/core/codecs/crc32-stream.js

@@ -37,7 +37,7 @@ class Crc32Stream extends TransformStream {
 				this.crc32 = new Crc32();
 			},
 			transform(chunk) {
-				if (chunk) {
+				if (chunk && chunk.length) {
 					this.crc32.append(chunk);
 				}
 			},

package/lib/core/codecs/zip-crypto-stream.js

@@ -34,7 +34,7 @@ import { ERR_INVALID_PASSWORD } from "./aes-crypto-stream.js";
 
 const HEADER_LENGTH = 12;
 
-class ZipCryptoDecryptStream extends TransformStream {
+class ZipCryptoDecryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		let stream;
@@ -68,7 +68,7 @@ class ZipCryptoDecryptStream extends TransformStream {
 	}
 }
 
-class ZipCryptoEncryptStream extends TransformStream {
+class ZipCryptoEncryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		super({
@@ -106,8 +106,8 @@ class ZipCryptoEncryptStream extends TransformStream {
 }
 
 export {
-	ZipCryptoDecryptStream,
-	ZipCryptoEncryptStream,
+	ZipCryptoDecryptionStream,
+	ZipCryptoEncryptionStream,
 	ERR_INVALID_PASSWORD
 };
 

package/lib/core/configuration.js

@@ -28,6 +28,7 @@
 
 /* global navigator */
 
+const MINIMUM_CHUNK_SIZE = 64;
 const DEFAULT_CONFIGURATION = {
 	chunkSize: 512 * 1024,
 	maxWorkers: (typeof navigator != "undefined" && navigator.hardwareConcurrency) || 2,
@@ -40,13 +41,18 @@ const config = Object.assign({}, DEFAULT_CONFIGURATION);
 
 export {
 	configure,
-	getConfiguration
+	getConfiguration,
+	getChunkSize
 };
 
 function getConfiguration() {
 	return config;
 }
 
+function getChunkSize(config) {
+	return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
+}
+
 function configure(configuration) {
 	if (configuration.baseURL !== undefined) {
 		config.baseURL = configuration.baseURL;

package/lib/core/engine.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const MINIMUM_CHUNK_SIZE = 64;
+// const MINIMUM_CHUNK_SIZE = 64;
 const ERR_ABORT = "Abort error";
 
 export {
@@ -34,39 +34,35 @@ export {
 	processData
 };
 
-async function processData(codec, reader, writer, offset, inputLengthGetter, config, options) {
-	const chunkSize = Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
-	const signal = options.signal;
+async function processData(codec, reader, writer, size, { signal, onprogress }) {
 	let length = 0;
 	let chunkOffset = 0;
 
 	const result = new Promise((resolve, reject) => {
 		codec.pull = async () => {
 			testAborted(signal, codec);
-			const inputLength = inputLengthGetter();
-			let currentChunkOffset = chunkOffset;
-			chunkOffset += chunkSize;
-			const value = await reader.readUint8Array(currentChunkOffset + offset, Math.min(chunkSize, inputLength - currentChunkOffset));
-			const done = chunkOffset > inputLength;
-			return { value, done };
+			const result = await reader.read();
+			chunkOffset += result.length;
+			return result;
 		};
 		codec.ondata = async ({ value, done }) => {
 			try {
 				testAborted(signal, codec);
-				const inputLength = inputLengthGetter();
 				const { data, signature } = value;
 				if (data && data.length) {
 					length += data.length;
-					await writer.writeUint8Array(data);
+					await writer.ready;
+					await writer.write(data);
 				}
-				if (options.onprogress) {
+				if (onprogress) {
 					try {
-						options.onprogress(chunkOffset, inputLength);
+						onprogress(chunkOffset, size());
 					} catch (error) {
 						// ignored
 					}
 				}
 				if (done) {
+					await writer.ready;
 					resolve({ signature, length });
 				}
 			} catch (error) {