neozipkit 0.1.1

package/dist/shared/components/ZipCrypto.js

@@ -0,0 +1,78 @@
+// ======================================
+//	ZipCrypto.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Zip Cryptography Routines
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.encrypter = encrypter;
+exports.decrypter = decrypter;
+const crypto_1 = require("crypto");
+const Util_1 = require("./Util");
+const Headers_1 = require("../constants/Headers");
+// Return the SHA256 hash of a buffer
+function sha256(data) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    return hash
+        .update(data)
+        .digest('hex');
+}
+class InitKeys {
+    constructor(pw) {
+        this.keys = new Uint32Array([0x12345678, 0x23456789, 0x34567890]);
+        const pass = typeof pw === 'string' ? Buffer.from(pw) : pw;
+        for (let i = 0; i < pass.length; i++) {
+            this.updateKeys(pass[i]);
+        }
+    }
+    updateKeys(byteValue) {
+        this.keys[0] = (0, Util_1.crc32update)(this.keys[0], byteValue);
+        this.keys[1] = ((this.keys[1] + (this.keys[0] & 0xff)) * 0x08088405 + 1) >>> 0;
+        this.keys[2] = (0, Util_1.crc32update)(this.keys[2], this.keys[1] >>> 24);
+        return byteValue;
+    }
+    next() {
+        const k = (this.keys[2] | 2) >>> 0; // key
+        return ((0, Util_1.uMul)(k, k ^ 1) >> 8) & 0xff; // decode
+    }
+}
+// Return encrypting function, result and pos is here so we dont have to merge buffers later
+function make_encrypter(pwd) {
+    const keys = new InitKeys(pwd);
+    return function (data, result, pos = 0) {
+        // result - we create new Buffer for results
+        if (!result)
+            result = Buffer.alloc(data.length);
+        // process input data
+        for (let c of data) {
+            const k = keys.next(); // save key byte
+            result[pos++] = c ^ k; // save val
+            keys.updateKeys(c); // update keys with decoded byte
+        }
+        return result;
+    };
+}
+// Encrypt data with password and include a checkByte verification byte at the end
+function encrypter(data, checkByte, pwd) {
+    if (!data)
+        return null;
+    const _encrypter = make_encrypter(pwd);
+    const salt = (0, crypto_1.randomFillSync)(Buffer.alloc(Headers_1.ENCRYPT_HDR_SIZE));
+    salt[Headers_1.ENCRYPT_HDR_SIZE - 1] = checkByte;
+    // create encryption header
+    const result = Buffer.alloc(data.length + Headers_1.ENCRYPT_HDR_SIZE);
+    _encrypter(salt, result);
+    // encode content
+    return _encrypter(data, result, Headers_1.ENCRYPT_HDR_SIZE);
+}
+// Return the decrypter function
+function decrypter(pwd) {
+    const keys = new InitKeys(pwd);
+    return function (data) {
+        for (let i = 0; i < data.length; i++) {
+            data[i] = keys.updateKeys(data[i] ^ keys.next());
+        }
+        return data;
+    };
+}

package/dist/shared/components/merkleTree.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Configuration options for Merkle tree construction
+ */
+interface MerkleTreeOptions {
+    hashLeaves: boolean;
+    sortLeaves: boolean;
+    sortPairs: boolean;
+    duplicateOdd: boolean;
+}
+/**
+ * Implementation of a Merkle Tree (hash tree) using SHA-256
+ *
+ * A Merkle tree is a binary tree where each non-leaf node is the hash of its two children.
+ * This allows efficient verification of large datasets by only storing/transmitting the root hash
+ * and generating proofs of inclusion for individual items.
+ */
+export declare class MerkleTree {
+    private leaves;
+    private layers;
+    private options;
+    /**
+     * Creates a new Merkle tree from an array of leaf nodes
+     * @param leaves - Array of leaf node data as Buffers
+     * @param options - Configuration options for tree construction
+     */
+    constructor(leaves: Buffer[], options?: Partial<MerkleTreeOptions>);
+    /**
+     * Computes SHA-256 hash of input data
+     * @param data - Data to hash
+     * @returns Buffer containing hash
+     */
+    private hash;
+    /**
+     * Combines two child hashes to create parent hash
+     * @param left - Left child hash
+     * @param right - Right child hash
+     * @returns Combined hash of children
+     */
+    private combinedHash;
+    /**
+     * Builds the Merkle tree by creating successive layers of hashes
+     * @param nodes - Array of nodes in current layer
+     */
+    private createHashes;
+    /**
+     * Gets the root hash of the Merkle tree
+     * @returns Buffer containing root hash
+     */
+    getRoot(): Buffer;
+    /**
+     * Generates a proof of inclusion for a leaf node
+     * @param leaf - The leaf node to generate proof for
+     * @returns Array of sibling hashes needed to reconstruct root
+     * @throws Error if leaf not found in tree
+     */
+    getProof(leaf: Buffer): Buffer[];
+    /**
+     * Verifies a proof of inclusion for a leaf node
+     * @param proof - Array of sibling hashes from getProof()
+     * @param targetHash - Hash of the leaf node being verified
+     * @param root - Expected root hash
+     * @returns boolean indicating if proof is valid
+     */
+    verify(proof: Buffer[], targetHash: Buffer, root: Buffer): boolean;
+}
+export {};

package/dist/shared/components/merkleTree.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleTree = void 0;
+const crypto_1 = require("crypto");
+/**
+ * Implementation of a Merkle Tree (hash tree) using SHA-256
+ *
+ * A Merkle tree is a binary tree where each non-leaf node is the hash of its two children.
+ * This allows efficient verification of large datasets by only storing/transmitting the root hash
+ * and generating proofs of inclusion for individual items.
+ */
+class MerkleTree {
+    /**
+     * Creates a new Merkle tree from an array of leaf nodes
+     * @param leaves - Array of leaf node data as Buffers
+     * @param options - Configuration options for tree construction
+     */
+    constructor(leaves, options = {}) {
+        this.options = {
+            hashLeaves: false,
+            sortLeaves: true,
+            sortPairs: true,
+            duplicateOdd: true,
+            ...options
+        };
+        // Process leaves according to options
+        this.leaves = leaves.map(leaf => {
+            if (this.options.hashLeaves) {
+                return this.hash(leaf);
+            }
+            return Buffer.isBuffer(leaf) ? leaf : Buffer.from(leaf);
+        });
+        if (this.options.sortLeaves) {
+            this.leaves.sort(Buffer.compare);
+        }
+        this.layers = [this.leaves];
+        this.createHashes(this.leaves);
+    }
+    /**
+     * Computes SHA-256 hash of input data
+     * @param data - Data to hash
+     * @returns Buffer containing hash
+     */
+    hash(data) {
+        return (0, crypto_1.createHash)('sha256').update(data).digest();
+    }
+    /**
+     * Combines two child hashes to create parent hash
+     * @param left - Left child hash
+     * @param right - Right child hash
+     * @returns Combined hash of children
+     */
+    combinedHash(left, right) {
+        if (this.options.sortPairs && Buffer.compare(left, right) > 0) {
+            [left, right] = [right, left];
+        }
+        return this.hash(Buffer.concat([left, right]));
+    }
+    /**
+     * Builds the Merkle tree by creating successive layers of hashes
+     * @param nodes - Array of nodes in current layer
+     */
+    createHashes(nodes) {
+        while (nodes.length > 1) {
+            const layerIndex = this.layers.length;
+            this.layers.push([]);
+            // Process pairs of nodes
+            for (let i = 0; i < nodes.length - 1; i += 2) {
+                const left = nodes[i];
+                const right = nodes[i + 1];
+                const hash = this.combinedHash(left, right);
+                this.layers[layerIndex].push(hash);
+            }
+            // Handle odd number of nodes
+            if (nodes.length % 2 === 1) {
+                const last = nodes[nodes.length - 1];
+                if (this.options.duplicateOdd) {
+                    // Duplicate the last node if odd
+                    const hash = this.combinedHash(last, last);
+                    this.layers[layerIndex].push(hash);
+                }
+                else {
+                    // Push last node up to next layer
+                    this.layers[layerIndex].push(last);
+                }
+            }
+            nodes = this.layers[layerIndex];
+        }
+    }
+    /**
+     * Gets the root hash of the Merkle tree
+     * @returns Buffer containing root hash
+     */
+    getRoot() {
+        return this.layers[this.layers.length - 1][0];
+    }
+    /**
+     * Generates a proof of inclusion for a leaf node
+     * @param leaf - The leaf node to generate proof for
+     * @returns Array of sibling hashes needed to reconstruct root
+     * @throws Error if leaf not found in tree
+     */
+    getProof(leaf) {
+        let index = this.leaves.findIndex(item => item.equals(leaf));
+        if (index === -1) {
+            throw new Error('Leaf not found in tree');
+        }
+        return this.layers.reduce((proof, layer) => {
+            if (layer.length === 1)
+                return proof;
+            const pairIndex = index % 2 === 0 ? index + 1 : index - 1;
+            if (pairIndex < layer.length) {
+                proof.push(layer[pairIndex]);
+            }
+            index = Math.floor(index / 2);
+            return proof;
+        }, []);
+    }
+    /**
+     * Verifies a proof of inclusion for a leaf node
+     * @param proof - Array of sibling hashes from getProof()
+     * @param targetHash - Hash of the leaf node being verified
+     * @param root - Expected root hash
+     * @returns boolean indicating if proof is valid
+     */
+    verify(proof, targetHash, root) {
+        let computedHash = targetHash;
+        for (const proofElement of proof) {
+            computedHash = Buffer.compare(computedHash, proofElement) <= 0
+                ? this.combinedHash(computedHash, proofElement)
+                : this.combinedHash(proofElement, computedHash);
+        }
+        return computedHash.equals(root);
+    }
+}
+exports.MerkleTree = MerkleTree;

package/dist/shared/constants/Errors.d.ts

@@ -0,0 +1,53 @@
+declare const _default: {
+    INVALID_LOC: string;
+    INVALID_CEN: string;
+    INVALID_END: string;
+    NO_DATA: string;
+    FILE_IN_THE_WAY: string;
+    UNKNOWN_METHOD: string;
+    STRONG_ENCRYPT_UNSUPPORTED: string;
+    INVALID_TIMESTAMP: string;
+    TIMESTAMP_FAILED: string;
+    AVAIL_DATA: string;
+    INVALID_DISTANCE: string;
+    TO_MANY_CODES: string;
+    INVALID_REPEAT_LEN: string;
+    INVALID_REPEAT_FIRST: string;
+    INCOMPLETE_CODES: string;
+    INVALID_DYN_DISTANCE: string;
+    INVALID_CODES_LEN: string;
+    INVALID_STORE_BLOCK: string;
+    INVALID_BLOCK_TYPE: string;
+    INVALID_CMP_DATA_LENGTH: string;
+    EXTRACT_FAILED: string;
+    INVALID_CRC: string;
+    UNKNOWN_SHA256: string;
+    INVALID_SHA256: string;
+    CANT_EXTRACT_FILE: string;
+    CANT_OVERRIDE: string;
+    NO_ZIP: string;
+    NO_ENTRY: string;
+    DIRECTORY_CONTENT_ERROR: string;
+    FILE_NOT_FOUND: string;
+    NOT_IMPLEMENTED: string;
+    INVALID_FILENAME: string;
+    INVALID_FORMAT: string;
+    NO_STREAM_SUPPORT: string;
+    NO_BLOB_SUPPORT: string;
+    NO_FILE_READER_SUPPORT: string;
+    NO_FILES: string;
+    DATATYPE_STRING_UNSUPPORTED: string;
+    DATATYPE_ARRAY_UNSUPPORTED: string;
+    DATATYPE_BUFFER_UNSUPPORTED: string;
+    DATATYPE_BLOB_UNSUPPORTED: string;
+    DATATYPE_U8ARRAY_UNSUPPORTED: string;
+    DATATYPE_ARRAYBUFFER_UNSUPPORTED: string;
+    DATATYPE_UNSUPPORTED: string;
+    COMPRESS_FAILED: string;
+    COMPRESSION_ERROR: string;
+    DECOMPRESSION_ERROR: string;
+    ENCRYPT_FAILED: string;
+    CERTIFICATE_OTS_BAD: string;
+    CERTIFICATE_OTS_FAILED: string;
+};
+export default _default;

package/dist/shared/constants/Errors.js

@@ -0,0 +1,69 @@
+"use strict";
+// ======================================
+//	Errors.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Error messages
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    /* Header error messages */
+    INVALID_LOC: "Invalid LOC header (bad signature)",
+    INVALID_CEN: "Invalid CEN header (bad signature)",
+    INVALID_END: "Invalid END header (bad signature)",
+    /* ZipEntry error messages*/
+    NO_DATA: "Nothing to decompress",
+    FILE_IN_THE_WAY: "There is a file in the way: %s",
+    UNKNOWN_METHOD: "Invalid/unsupported compression method",
+    /* Encryption Errors */
+    STRONG_ENCRYPT_UNSUPPORTED: "Strong Encryption is not supported",
+    /* Timestamp error messages */
+    INVALID_TIMESTAMP: "Invalid timestamp",
+    TIMESTAMP_FAILED: "Failed to create the timestamp",
+    /* Inflater error messages */
+    AVAIL_DATA: "inflate::Available inflate data did not terminate",
+    INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+    TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+    INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+    INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+    INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+    INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+    INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+    INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+    INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+    /* Extract error messages */
+    INVALID_CMP_DATA_LENGTH: "Compressed data length does not match the expected length",
+    EXTRACT_FAILED: "Failed to extract file",
+    INVALID_CRC: "CRC32 checksum does not match the expected value",
+    UNKNOWN_SHA256: "The SHA-256 hash has not been saved",
+    INVALID_SHA256: "The SHA-256 hash does not match the expected value",
+    /* NEO-ZIP error messages */
+    CANT_EXTRACT_FILE: "Could not extract the file",
+    CANT_OVERRIDE: "Target file already exists",
+    NO_ZIP: "No zip file was loaded",
+    NO_ENTRY: "Entry doesn't exist",
+    DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+    FILE_NOT_FOUND: "File not found: %s",
+    NOT_IMPLEMENTED: "Not implemented",
+    INVALID_FILENAME: "Invalid filename",
+    INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+    // NeoZipKit error messages
+    NO_STREAM_SUPPORT: "Streams are not supported in this environment",
+    NO_BLOB_SUPPORT: "Blobs are not supported in this environment",
+    NO_FILE_READER_SUPPORT: "FileReader is not supported in this environment",
+    // Create Zip error messages
+    NO_FILES: "No files added, Zip file not created",
+    DATATYPE_STRING_UNSUPPORTED: "The String type is not supported by this platform.",
+    DATATYPE_ARRAY_UNSUPPORTED: "The Array type is not supported by this platform.",
+    DATATYPE_BUFFER_UNSUPPORTED: "The Buffer type is not supported by this platform.",
+    DATATYPE_BLOB_UNSUPPORTED: "The Blob type is not supported by this platform.",
+    DATATYPE_U8ARRAY_UNSUPPORTED: "The uint8Array type is not supported by this platform.",
+    DATATYPE_ARRAYBUFFER_UNSUPPORTED: "The ArrayBuffer type is not supported by this platform.",
+    DATATYPE_UNSUPPORTED: "Unsupported input type.",
+    COMPRESS_FAILED: 'Failed to compress data',
+    COMPRESSION_ERROR: 'Error occurred during compression',
+    DECOMPRESSION_ERROR: 'Error occurred during decompression',
+    ENCRYPT_FAILED: 'Encryption failed',
+    // Certificate error messages
+    CERTIFICATE_OTS_BAD: 'Unable to create OTS certificate, bad OTS timestamp',
+    CERTIFICATE_OTS_FAILED: 'Failed to create OTS certificate',
+};

package/dist/shared/constants/Headers.d.ts

@@ -0,0 +1,167 @@
+export declare const LOCAL_FILE_HEADER = "PK\u0003\u0004";
+export declare const CENTRAL_FILE_HEADER = "PK\u0001\u0002";
+export declare const CENTRAL_DIRECTORY_END = "PK\u0005\u0006";
+export declare const ZIP64_CENTRAL_DIRECTORY_LOCATOR = "PK\u0006\u0007";
+export declare const ZIP64_CENTRAL_DIRECTORY_END = "PK\u0006\u0006";
+export declare const DATA_DESCRIPTOR = "PK\u0007\b";
+export declare const TIMESTAMP_SUBMITTED = "META-INF/TS-SUBMIT.OTS";
+export declare const TIMESTAMP_METADATA = "META-INF/TIMESTAMP.OTS";
+export declare const TOKENIZED_METADATA = "META-INF/NZIP.TOKEN";
+export declare const LOCAL_HDR: {
+    SIZE: number;
+    SIGNATURE: number;
+    VER_EXTRACT: number;
+    FLAGS: number;
+    COMPRESSION: number;
+    TIMEDATE_DOS: number;
+    CRC: number;
+    CMP_SIZE: number;
+    UNCMP_SIZE: number;
+    FNAME_LEN: number;
+    EXTRA_LEN: number;
+};
+export declare const ENCRYPT_HDR_SIZE = 12;
+export declare const DATA_DESC: {
+    SIGNATURE: number;
+    SIZE: number;
+    CRC: number;
+    CMP_SIZE: number;
+    UNCMP_SIZE: number;
+};
+export declare const CENTRAL_DIR: {
+    SIZE: number;
+    SIGNATURE: number;
+    VER_MADE: number;
+    VER_EXT: number;
+    FLAGS: number;
+    CMP_METHOD: number;
+    TIMEDATE_DOS: number;
+    CRC: number;
+    CMP_SIZE: number;
+    UNCMP_SIZE: number;
+    FNAME_LEN: number;
+    EXTRA_LEN: number;
+    COMMENT_LEN: number;
+    DISK_NUM: number;
+    INT_FILE_ATTR: number;
+    EXT_FILE_ATTR: number;
+    LOCAL_HDR_OFFSET: number;
+};
+export declare const CENTRAL_END: {
+    SIZE: number;
+    SIGNATURE: number;
+    VOL_NUM: number;
+    VOLDIR_START: number;
+    VOL_ENTRIES: number;
+    TOTAL_ENTRIES: number;
+    CENTRAL_DIR_SIZE: number;
+    CENTRAL_DIR_OFFSET: number;
+    ZIP_COMMENT_LEN: number;
+};
+export declare const ZIP64_CENTRAL_DIR: {
+    SIGNATURE: number;
+    SIZE: number;
+    LEAD: number;
+    SIZE_FIELD: number;
+    VER_MADEBY: number;
+    VER_NEEDED: number;
+    VOL_NUM: number;
+    VOLDIR_START: number;
+    VOL_ENTRIES: number;
+    TOTAL_ENTRIES: number;
+    CENTRAL_DIR_SIZE: number;
+    CENTRAL_DIR_OFFSET: number;
+    EXTRA_FIELD: number;
+};
+export declare const ZIP64_CENTRAL_END: {
+    SIZE: number;
+    SIGNATURE: number;
+    VOL_NUM: number;
+    CENTRAL_DIR_OFFSET: number;
+    TOTAL_DISKS: number;
+};
+export declare const CMP_METHOD: {
+    STORED: number;
+    SHRUNK: number;
+    REDUCED1: number;
+    REDUCED2: number;
+    REDUCED3: number;
+    REDUCED4: number;
+    IMPLODED: number;
+    DEFLATED: number;
+    ENHANCED_DEFLATE: number;
+    BZIP2: number;
+    LZMA: number;
+    IBM_TERSE: number;
+    IBM_LZ77: number;
+    ZSTD: number;
+    AES_ENCRYPT: number;
+};
+export declare const GP_FLAG: {
+    ENCRYPTED: number;
+    COMPRESSION1: number;
+    COMPRESSION2: number;
+    DATA_DESC: number;
+    ENHANCED_DEFLATE: number;
+    PATCHED: number;
+    STRONG_ENCRYPT: number;
+    EFS: number;
+    MASK: number;
+};
+export declare const EXTENSIBLE_DATA_FIELDS: {
+    ID: number;
+    SIZE: number;
+};
+export declare const HDR_ID: {
+    ZIP64: number;
+    AVINFO: number;
+    PFS: number;
+    OS2: number;
+    NTFS: number;
+    OPENVMS: number;
+    UNIX: number;
+    FORK: number;
+    PATCH: number;
+    x509PKCS7: number;
+    x509CERT_IDF: number;
+    x509CERT_IDC: number;
+    STRONG_ENC: number;
+    RECORD_MGT: number;
+    x509PKCS7RL: number;
+    IBM1: number;
+    IBM2: number;
+    SHA256: number;
+    POSZIP: number;
+    UNV_TIME: number;
+    UID_GID: number;
+    UNICODE_PATH: number;
+};
+export declare const FILE_SYSTEM: {
+    MSDOS: number;
+    AMIGA: number;
+    OPENVMS: number;
+    UNIX: number;
+    VM_CMS: number;
+    ATARI: number;
+    OS2: number;
+    MAC: number;
+    CP_M: number;
+    NTFS: number;
+    MVS: number;
+    VSE: number;
+    ACORN: number;
+    VFAT: number;
+    ALTMVS: number;
+    BEOS: number;
+    TANDEM: number;
+    OS400: number;
+    DARWIN: number;
+};
+export declare const DOS_FILE_ATTR: {
+    READONLY: number;
+    HIDDEN: number;
+    SYSTEM: number;
+    VOLUME: number;
+    DIRECTORY: number;
+    ARCHIVE: number;
+};