@cj-tech-master/excelts 5.1.18 → 6.0.0-beta.1

package/dist/cjs/modules/archive/crypto/zip-crypto.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Traditional PKWARE ZIP encryption (ZipCrypto).
+ *
+ * This implements the "traditional ZIP encryption" algorithm as specified
+ * in the PKWARE APPNOTE.TXT (section 6.1.5 "Traditional PKWARE Encryption").
+ *
+ * WARNING: ZipCrypto is cryptographically weak and should only be used
+ * for backward compatibility. Use AES encryption for new archives.
+ *
+ * References:
+ * - PKWARE APPNOTE.TXT 6.1.5 - Traditional Encryption
+ * - https://www.forensicfocus.com/stable/wp-content/uploads/2009/04/zip_encryption.pdf
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZIP_CRYPTO_HEADER_SIZE = void 0;
+exports.zipCryptoInitKeys = zipCryptoInitKeys;
+exports.zipCryptoUpdateKeys = zipCryptoUpdateKeys;
+exports.zipCryptoGetStreamByte = zipCryptoGetStreamByte;
+exports.zipCryptoDecryptByte = zipCryptoDecryptByte;
+exports.zipCryptoEncryptByte = zipCryptoEncryptByte;
+exports.zipCryptoDecryptHeader = zipCryptoDecryptHeader;
+exports.zipCryptoCreateHeader = zipCryptoCreateHeader;
+exports.zipCryptoDecryptData = zipCryptoDecryptData;
+exports.zipCryptoEncryptData = zipCryptoEncryptData;
+exports.zipCryptoDecrypt = zipCryptoDecrypt;
+exports.zipCryptoEncrypt = zipCryptoEncrypt;
+exports.zipCryptoCheckPassword = zipCryptoCheckPassword;
+const crc32_base_1 = require("../compression/crc32.base.js");
+const binary_1 = require("../../../utils/binary.js");
+/**
+ * ZipCrypto encryption header size.
+ * The first 12 bytes of encrypted data are the encryption header.
+ */
+exports.ZIP_CRYPTO_HEADER_SIZE = 12;
+/**
+ * Initialize ZipCrypto state with a password.
+ */
+function zipCryptoInitKeys(password) {
+    const state = {
+        key0: 0x12345678,
+        key1: 0x23456789,
+        key2: 0x34567890
+    };
+    const bytes = typeof password === "string" ? (0, binary_1.stringToUint8Array)(password) : password;
+    for (let i = 0; i < bytes.length; i++) {
+        zipCryptoUpdateKeys(state, bytes[i]);
+    }
+    return state;
+}
+/**
+ * Update the cipher state with a single byte.
+ */
+function zipCryptoUpdateKeys(state, byte) {
+    state.key0 = (0, crc32_base_1.crc32UpdateByte)(state.key0, byte);
+    state.key1 = (state.key1 + (state.key0 & 0xff)) >>> 0;
+    state.key1 = ((Math.imul(state.key1, 134775813) >>> 0) + 1) >>> 0;
+    state.key2 = (0, crc32_base_1.crc32UpdateByte)(state.key2, (state.key1 >>> 24) & 0xff);
+}
+/**
+ * Get the next stream byte for encryption/decryption.
+ */
+function zipCryptoGetStreamByte(state) {
+    const temp = (state.key2 | 2) >>> 0;
+    return (Math.imul(temp, temp ^ 1) >>> 8) & 0xff;
+}
+/**
+ * Decrypt a single byte and update state.
+ */
+function zipCryptoDecryptByte(state, cipher) {
+    const plain = (cipher ^ zipCryptoGetStreamByte(state)) & 0xff;
+    zipCryptoUpdateKeys(state, plain);
+    return plain;
+}
+/**
+ * Encrypt a single byte and update state.
+ */
+function zipCryptoEncryptByte(state, plain) {
+    const cipher = (plain ^ zipCryptoGetStreamByte(state)) & 0xff;
+    zipCryptoUpdateKeys(state, plain);
+    return cipher;
+}
+/**
+ * Decrypt the encryption header and verify.
+ *
+ * @param state - Initialized cipher state
+ * @param header - 12-byte encryption header from encrypted data
+ * @param crc32 - Expected CRC32 of the uncompressed data (for verification)
+ * @param lastModTime - Last modified time field (alternative verification)
+ * @returns true if header passes verification
+ */
+function zipCryptoDecryptHeader(state, header, crc32, lastModTime) {
+    if (header.length !== exports.ZIP_CRYPTO_HEADER_SIZE) {
+        return false;
+    }
+    // Decrypt all 12 header bytes
+    const decrypted = new Uint8Array(exports.ZIP_CRYPTO_HEADER_SIZE);
+    for (let i = 0; i < exports.ZIP_CRYPTO_HEADER_SIZE; i++) {
+        decrypted[i] = zipCryptoDecryptByte(state, header[i]);
+    }
+    // The last byte should match either:
+    // 1. The high byte of CRC32 (modern approach)
+    // 2. The high byte of the last modified time (older approach, for data descriptor)
+    const checkByte = decrypted[11];
+    const crcHighByte = (crc32 >>> 24) & 0xff;
+    return (checkByte === crcHighByte ||
+        (lastModTime !== undefined && checkByte === ((lastModTime >>> 8) & 0xff)));
+}
+/**
+ * Generate an encryption header for writing.
+ *
+ * @param state - Initialized cipher state
+ * @param crc32 - CRC32 of the uncompressed data
+ * @param getRandomBytes - Function to generate random bytes
+ * @returns 12-byte encrypted header
+ */
+function zipCryptoCreateHeader(state, crc32, getRandomBytes) {
+    const header = new Uint8Array(exports.ZIP_CRYPTO_HEADER_SIZE);
+    // First 11 bytes are random
+    const random = getRandomBytes(11);
+    for (let i = 0; i < 11; i++) {
+        header[i] = zipCryptoEncryptByte(state, random[i]);
+    }
+    // Last byte is high byte of CRC32 for verification
+    const checkByte = (crc32 >>> 24) & 0xff;
+    header[11] = zipCryptoEncryptByte(state, checkByte);
+    return header;
+}
+/**
+ * Decrypt data in-place after header decryption.
+ */
+function zipCryptoDecryptData(state, data) {
+    const output = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        output[i] = zipCryptoDecryptByte(state, data[i]);
+    }
+    return output;
+}
+/**
+ * Encrypt data after header encryption.
+ */
+function zipCryptoEncryptData(state, data) {
+    const output = new Uint8Array(data.length);
+    for (let i = 0; i < data.length; i++) {
+        output[i] = zipCryptoEncryptByte(state, data[i]);
+    }
+    return output;
+}
+/**
+ * High-level decryption interface for ZipCrypto.
+ *
+ * @param encryptedData - Full encrypted data including 12-byte header
+ * @param password - Password string or bytes
+ * @param crc32 - Expected CRC32 for header verification
+ * @param lastModTime - Optional last modified time for alternative verification
+ * @returns Decrypted data (excluding header) or null if verification fails
+ */
+function zipCryptoDecrypt(encryptedData, password, crc32, lastModTime) {
+    if (encryptedData.length < exports.ZIP_CRYPTO_HEADER_SIZE) {
+        return null;
+    }
+    const state = zipCryptoInitKeys(password);
+    // Decrypt and verify header
+    const header = encryptedData.subarray(0, exports.ZIP_CRYPTO_HEADER_SIZE);
+    if (!zipCryptoDecryptHeader(state, header, crc32, lastModTime)) {
+        return null;
+    }
+    // Decrypt remaining data directly
+    const payloadLen = encryptedData.length - exports.ZIP_CRYPTO_HEADER_SIZE;
+    const output = new Uint8Array(payloadLen);
+    for (let i = 0; i < payloadLen; i++) {
+        output[i] = zipCryptoDecryptByte(state, encryptedData[exports.ZIP_CRYPTO_HEADER_SIZE + i]);
+    }
+    return output;
+}
+/**
+ * High-level encryption interface for ZipCrypto.
+ *
+ * @param data - Plain data to encrypt
+ * @param password - Password string or bytes
+ * @param crc32 - CRC32 of the data
+ * @param getRandomBytes - Function to generate random bytes
+ * @returns Encrypted data including 12-byte header
+ */
+function zipCryptoEncrypt(data, password, crc32, getRandomBytes) {
+    const state = zipCryptoInitKeys(password);
+    // Allocate output buffer once
+    const output = new Uint8Array(exports.ZIP_CRYPTO_HEADER_SIZE + data.length);
+    // Create and encrypt header directly into output
+    const random = getRandomBytes(11);
+    for (let i = 0; i < 11; i++) {
+        output[i] = zipCryptoEncryptByte(state, random[i]);
+    }
+    output[11] = zipCryptoEncryptByte(state, (crc32 >>> 24) & 0xff);
+    // Encrypt data directly into output
+    for (let i = 0; i < data.length; i++) {
+        output[exports.ZIP_CRYPTO_HEADER_SIZE + i] = zipCryptoEncryptByte(state, data[i]);
+    }
+    return output;
+}
+/**
+ * Check if a password is valid for ZipCrypto-encrypted data without full decryption.
+ * This only verifies the encryption header check byte.
+ *
+ * @param encryptedData - Full encrypted data including 12-byte header
+ * @param password - Password string or bytes
+ * @param crc32 - Expected CRC32 for header verification
+ * @param lastModTime - Optional last modified time for alternative verification
+ * @returns true if password verification passes, false otherwise
+ */
+function zipCryptoCheckPassword(encryptedData, password, crc32, lastModTime) {
+    if (encryptedData.length < exports.ZIP_CRYPTO_HEADER_SIZE) {
+        return false;
+    }
+    const state = zipCryptoInitKeys(password);
+    const header = encryptedData.subarray(0, exports.ZIP_CRYPTO_HEADER_SIZE);
+    return zipCryptoDecryptHeader(state, header, crc32, lastModTime);
+}

package/dist/cjs/modules/archive/formats/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArchive = createArchive;
+exports.createReader = createReader;
+const zip_archive_1 = require("../zip/zip-archive.js");
+const zip_reader_1 = require("../unzip/zip-reader.js");
+const tar_archive_1 = require("../tar/tar-archive.js");
+function createArchive(options = {}) {
+    if (options.format === "tar") {
+        return new tar_archive_1.TarArchive({
+            modTime: options.modTime,
+            signal: options.signal,
+            onProgress: options.onProgress,
+            progressIntervalMs: options.progressIntervalMs
+        });
+    }
+    // Narrow for ZIP implementation.
+    const zipOptions = { ...options, format: "zip" };
+    return (0, zip_archive_1.createZipArchive)(zipOptions);
+}
+function createReader(source, options = {}) {
+    if (options.format === "tar") {
+        return new tar_archive_1.TarReader(source, {
+            signal: options.signal,
+            onProgress: options.onProgress,
+            progressIntervalMs: options.progressIntervalMs
+        });
+    }
+    // Narrow for ZIP implementation.
+    const zipOptions = { ...options, format: "zip" };
+    return (0, zip_reader_1.createZipReader)(source, zipOptions);
+}

package/dist/cjs/modules/archive/formats/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });