neozipkit 0.1.1

package/src/shared/components/CertificateOTS.ts

@@ -0,0 +1,132 @@
+// ======================================
+//	CertificateOTS.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import fs from 'fs';
+import path from 'path';
+import ZipEntry from '../ZipEntry';
+
+import { 
+  TIMESTAMP_SUBMITTED,
+  TIMESTAMP_METADATA,
+} from '../constants/Headers';
+
+// Add this at the top of the file
+import type { AttestationValue } from '../types';
+
+/**
+ * Generates a certificate HTML document based on timestamp information
+ * 
+ * @param attestStr - Attestation message
+ * @param zipFile - Name of the zip file
+ * @param hashDigest - Hash digest of the zip file
+ * @param needsUpdateMsg - Message indicating if update is needed
+ * @param attestationValues - Array of attestation values
+ * @param zipEntries - Array of ZipEntry objects
+ * @param narrow - Whether to use narrow layout
+ * @returns Generated HTML certificate as string
+ */
+export default function CertificateTemplate(
+  attestStr: string | null,
+  zipFile: string, 
+  hashDigest: string,
+  needsUpdateMsg: string,
+  attestationValues: AttestationValue[],
+  zipEntries: ZipEntry[],
+  narrow?: boolean
+): string {
+  // Load the HTML template
+  let templatePath;
+  try {
+    // Try to find the template from the package root
+    templatePath = path.resolve(process.cwd(), 'assets/templates/certificate.html');
+    if (!fs.existsSync(templatePath)) {
+      // If not found in current working directory, try relative to this file
+      templatePath = path.resolve(__dirname, '../../assets/templates/certificate.html');
+    }
+    
+    if (!fs.existsSync(templatePath)) {
+      throw new Error('Certificate template not found');
+    }
+  } catch (error) {
+    console.error('Error resolving template path:', error);
+    return '';
+  }
+
+  // Read the template file
+  let htmlTemplate;
+  try {
+    htmlTemplate = fs.readFileSync(templatePath, 'utf8');
+  } catch (error) {
+    console.error('Error reading template file:', error);
+    return '';
+  }
+
+  const updateWarning = needsUpdateMsg || '';
+
+  // Generate attestation HTML
+  let attestHTML = '';
+  if (attestationValues && attestationValues.length > 0) {
+    attestationValues.forEach((attest) => {
+      attestHTML += `
+        <div class="key-value-pair">
+          <div class="key">Block Height:</div>
+          <div class="value">${attest['blockHeight']}</div>
+        </div>
+        <div class="key-value-pair">
+          <div class="key">Transaction:</div>
+          <div class="value">${attest['transactionId']}</div>
+        </div>
+        <div class="key-value-pair">
+          <div class="key">Merkle Root:</div>
+          <div class="value">${attest['merkleRoot']}</div>
+        </div>
+        <br/>
+      `;
+    });
+  }
+
+  // Generate files table HTML
+  let stampEntry = null;
+  let files = [];
+  for (const entry of zipEntries) {
+    if (entry.filename === TIMESTAMP_METADATA) {
+      stampEntry = entry;
+    } else if (entry.filename === TIMESTAMP_SUBMITTED) {
+      if (stampEntry == null)
+        stampEntry = entry;
+    } else if (entry.sha256) {
+      let file = {
+        name: entry.filename,
+        size: entry.uncompressedSize.toString(),
+        date: entry.toFormattedUTCDateString(),
+        hash: entry.sha256,
+      }
+      files.push(file);
+    }
+  }
+
+  let filesTableHTML = '';
+  files.forEach((file) => {
+    filesTableHTML += `
+      <tr>
+        <td class="table-data1">${file.name}</td>
+        <td class="table-data">${file.size}</td>
+        <td class="table-data">${file.date}</td>
+        <td class="table-data">${file.hash}</td>
+      </tr>
+    `;
+  });
+
+  // Replace placeholders in the template
+  let html = htmlTemplate
+    .replace(/{{ATTEST_STR}}/g, attestStr || '')
+    .replace(/{{UPDATE_WARNING}}/g, needsUpdateMsg ? `<div class="warning">${needsUpdateMsg}</div>` : '')
+    .replace(/{{ZIP_FILE}}/g, zipFile)
+    .replace(/{{HASH_DIGEST}}/g, hashDigest)
+    .replace(/{{ATTESTATION_HTML}}/g, attestHTML)
+    .replace(/{{FILES_TABLE_HTML}}/g, filesTableHTML);
+
+  return html;
+}

package/src/shared/components/FileSys.ts

@@ -0,0 +1,87 @@
+// ======================================
+//	FileSys.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import * as fs from 'fs';
+import * as pth from 'path';
+
+import Errors from '../constants/Errors';
+
+// Output a buffer to a file
+export function outputToFile(
+  fileName: string, 
+  buffer: Buffer, 
+  dirPath: string,
+  overwrite: boolean, 
+  never: boolean, 
+  fileAttr: number)
+{
+  // get Unix file permissions
+  const _fattr = fileAttr ? (((fileAttr >>> 0) | 0) >> 16) & 0xfff : 0; 
+
+  const _path = dirPath ? dirPath + pth.sep + fileName : fileName;
+
+  if (fs.existsSync(_path)) {
+    console.log('File exists: ', _path);
+    if (never) 
+      return false;
+    if (!overwrite) {
+      console.log('Overwrite file: ', _path);
+      return false; // cannot overwrite
+    }
+
+    const stat = fs.statSync(_path);
+    if (stat.isDirectory())
+      return false;
+  }
+  
+  // Check if we need to create a new folder
+  const _folder = pth.dirname(_path);
+  if (!fs.existsSync(_folder)) {
+    makeDir(_folder);
+  }
+
+  var fd;
+  try {
+    fd = fs.openSync(_path, "w", 438); // 0666
+  } catch (e) {
+    fs.chmodSync(_path, 438);
+    fd = fs.openSync(_path, "w", 438);
+  }
+  if (fd) {
+    try {
+      fs.writeSync(fd, buffer, 0, buffer.length, 0);
+    } finally {
+      fs.closeSync(fd);
+    }
+  }
+
+  if (_fattr)
+    fs.chmodSync(_path, _fattr);
+
+  return true;
+}
+
+// Make directories tree for a given path
+export function makeDir(folder: string) {
+  console.log('mkDir: ', folder);
+
+  // Sync - make directories tree
+  function mkdirSync(fpath: string) {
+    let resolvedPath = fpath.split(pth.sep)[0];
+    fpath.split(pth.sep).forEach(function (name) {
+      if (!name || name.endsWith(":")) return;
+      resolvedPath += pth.sep + name;
+      var stat;
+      try {
+        stat = fs.statSync(resolvedPath);
+      } catch (e) {
+        fs.mkdirSync(resolvedPath);
+      }
+      if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY.replace("%s", resolvedPath);
+    });
+  }
+
+  mkdirSync(folder);
+};

package/src/shared/components/HashAccumulator.ts

@@ -0,0 +1,113 @@
+// ======================================
+//  HashAccumulator.ts
+// ======================================
+
+import { MerkleTree } from './merkleTree';
+
+/**
+ * Class for accumulating and combining SHA-256 hashes using both XOR and Merkle tree methods
+ * 
+ * Usage example:
+ * ```typescript
+ * const accumulator = new HashAccumulator();
+ * accumulator.addHash('a1b2c3d4');
+ * accumulator.addHash('12345678');
+ * console.log(accumulator.xorHash()); // Outputs the accumulated XOR result
+ * console.log(accumulator.merkleRoot()); // Outputs the accumulated Merkle root
+ * ```
+ */
+export default class HashAccumulator {
+  private hashes: Buffer[];        // Array of hash buffers for Merkle tree
+  private xorResult: Buffer;       // Running XOR of all hashes
+
+  /**
+   * Creates a new HashAccumulator instance
+   * Initializes empty hash array and zero-filled XOR buffer
+   */
+  constructor() {
+    this.hashes = [];
+    this.xorResult = Buffer.alloc(32, 0);
+  }
+
+  /**
+   * Adds a hash to both the XOR accumulation and hash array
+   * @param hash - Hash value as hex string or Buffer
+   * The hash must be 32 bytes (SHA-256)
+   */
+  addHash(hash: string | Buffer) {
+    // Convert hash to Buffer if it's a string
+    const hashBuffer = typeof hash === 'string' 
+      ? Buffer.from(hash, 'hex') 
+      : hash;
+
+    // Add to array for Merkle tree
+    this.hashes.push(hashBuffer);
+
+    // XOR accumulation
+    for (let i = 0; i < 32; i++) {
+      this.xorResult[i] ^= hashBuffer[i];
+    }
+  }
+
+  /**
+   * Gets the accumulated XOR of all added hashes
+   * @returns Hex string of XOR result
+   */
+  xorHash(): string {
+    return this.xorResult.toString('hex');
+  }
+
+  /**
+   * Creates a Merkle tree from accumulated hashes and returns the root
+   * @returns Hex string of Merkle root, or null if no hashes added
+   */
+  merkleRoot(): string | null {
+    let merkleRoot = null;
+    if (this.hashes.length > 0) {
+      const tree = new MerkleTree(this.hashes, {
+        hashLeaves: false, // Leaves are already hashed
+        sortLeaves: true,  // Sort leaves for consistent results
+        sortPairs: true,   // Sort pairs for consistent results
+        duplicateOdd: true // Duplicate odd leaf for balanced tree
+      });
+      merkleRoot = tree.getRoot().toString('hex');
+    }
+
+    return merkleRoot;
+  }
+
+  /**
+   * Gets the number of hashes accumulated
+   * @returns Number of accumulated hashes
+   */
+  leafCount(): number {
+    return this.hashes.length;
+  }
+
+  /**
+   * Resets the accumulator to initial state
+   * Clears hash array and zeroes XOR buffer
+   */
+  clear() {
+    this.hashes = [];
+    this.xorResult = Buffer.alloc(32, 0);
+  }
+
+  /**
+   * Combines multiple hash results into a single Merkle root
+   * @param results - Array of objects containing merkleRoot properties
+   * @returns Combined Merkle root as hex string, or null if no valid roots
+   */
+  static combineResults(results: { merkleRoot?: string }[]) {
+    const accumulator = new HashAccumulator();
+    
+    // Combine all hashes
+    for (const result of results) {
+      if (result.merkleRoot) {
+        accumulator.addHash(result.merkleRoot);
+      }
+    }
+
+    return accumulator.merkleRoot();
+  }
+}

package/src/shared/components/Support.ts

@@ -0,0 +1,77 @@
+// ======================================
+//	Support.ts
+//  A utility module for detecting platform capabilities and features
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+
+/**
+ * Platform and environment feature detection utility
+ * Provides boolean flags indicating support for various features needed by NeoZip
+ * 
+ * @namespace Support
+ * @property {boolean} base64 - Always true, indicates base64 encoding support
+ * @property {boolean} array - Always true, indicates Array support
+ * @property {boolean} string - Always true, indicates String support
+ * @property {boolean} isNode - True if running in Node.js environment
+ * @property {boolean} buffer - True if Node.js Buffer is available
+ * @property {boolean} uint8array - True if Uint8Array is supported
+ * @property {boolean} arrayBuffer - True if both ArrayBuffer and Uint8Array are supported
+ * @property {boolean} blob - True if Blob creation with ArrayBuffer is supported
+ * @property {boolean} streams - True if ReadableStream and WritableStream are supported
+ * @property {boolean} fileReader - True if FileReader is supported
+ */
+const Support = {
+  /** Base64 encoding support (always true) */
+  base64: true,
+  /** Array support (always true) */
+  array: true,
+  /** String support (always true) */
+  string: true,
+
+  /** 
+   * Detects if code is running in Node.js environment
+   * True if process.versions.node exists, undefined in browser
+   */
+  isNode: true,
+  
+  /**
+   * Detects if Node.js Buffer is available
+   * True in Node.js, undefined in browser
+   */
+  buffer: true,
+
+  /**
+   * Detects support for Uint8Array typed array
+   * Used for binary data handling
+   */
+  uint8array: true,
+  
+  /**
+   * Detects support for both ArrayBuffer and Uint8Array
+   * Required for binary data operations
+   */
+  arrayBuffer: typeof ArrayBuffer !== "undefined" && typeof Uint8Array !== "undefined",
+
+  /**
+   * Detects support for Blob with ArrayBuffer
+   * Tests by attempting to create an empty ZIP Blob
+   * @returns {boolean} True if Blob creation succeeds
+   */
+  blob: true,
+
+  /**
+   * Detects support for Streams API
+   * Checks for ReadableStream/WritableStream in browser
+   * or 'stream' module in Node.js
+   * @returns {boolean} True if streams are supported in current environment
+   */
+  streams: true,
+  
+  /**
+   * Detects support for FileReader
+   * @returns {boolean} True if FileReader is supported
+   */
+  fileReader: false
+};
+
+export default Support;

package/src/shared/components/Util.ts

@@ -0,0 +1,113 @@
+// ======================================
+//	Util.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Utility functions
+
+import Support from "./Support";
+import Errors from "../constants/Errors";
+
+export const DATATYPE = {
+  STRING: "string",
+  BUFFER: "buffer",
+  ARRAY: "array",
+  ARRAYBUFFER: "arraybuffer",
+  U8ARRAY: "uint8array",
+  BLOB: "blob",
+  STREAM: "stream",
+};
+
+// Generate the CRC32 table
+const crcTable = new Uint32Array(256).map((t, crc) => {
+  for (let j = 0; j < 8; j++) {
+    if (0 !== (crc & 1)) {
+      crc = (crc >>> 1) ^ 0xedb88320;
+    } else {
+      crc >>>= 1;
+    }
+  }
+  return crc >>> 0;
+});
+
+// crc32 byte single update (actually same function is part of utils.crc32 function :) )
+export const crc32update = (pCrc32: number, bval: number) => {
+    return crcTable[(pCrc32 ^ bval) & 0xff] ^ (pCrc32 >>> 8);
+};
+
+// Return the CRC32 of a buffer
+export function crc32(buf: Buffer): number  {
+  if (typeof buf === "string") {
+      buf = Buffer.from(buf, "utf8");
+  }
+  // Generate crcTable
+  // if (!crcTable.length) genCRCTable();
+
+  let len = buf.length;
+  let crc = ~0;
+  for (let off = 0; off < len; )
+    crc = crcTable[(crc ^ buf[off++]) & 0xff] ^ (crc >>> 8);
+
+  // xor and cast as uint32 number
+  return ~crc >>> 0;
+};
+
+// Parse a 64-bit unsigned integer from a buffer
+export function readBigUInt64LE(buffer: Buffer, index: number): number {
+  var buf = Buffer.from(buffer.subarray(index, index + 8));
+  buf.swap64();
+
+  return parseInt(`0x${buf.toString("hex")}`);
+};
+
+// C-style uInt32 Multiply (discards higher bits, when JS multiply discards lower bits)
+export const uMul = (a: number, b: number) => Math.imul(a, b) >>> 0;
+
+interface StreamLike {
+  on: Function;
+  pause: Function;
+  resume: Function;
+}
+
+export function isStream(obj: unknown): obj is StreamLike {
+  if (!obj || typeof obj !== 'object') return false;
+  const streamLike = obj as StreamLike;
+  return typeof streamLike.on === "function" &&
+         typeof streamLike.pause === "function" &&
+         typeof streamLike.resume === "function";
+}
+
+// Return the type of the input.
+// The type will be in a format valid for JSZip.utils.transformTo : string, array, uint8array, arraybuffer.
+// If the type is not supported, throw an exception.
+export function getTypeOf(input: string|Buffer|Blob|Array<any>|ArrayBuffer|Uint8Array): string {
+  if (typeof input === "string") {
+    if (!Support.string)
+      throw new Error(Errors.DATATYPE_STRING_UNSUPPORTED);
+    return DATATYPE.STRING;
+  }
+  else if (Object.prototype.toString.call(input) === "[object Array]") {
+    if (!Support.array)
+      throw new Error(Errors.DATATYPE_ARRAY_UNSUPPORTED);
+    return DATATYPE.ARRAY;
+  }
+  else if (Buffer.isBuffer(input)) {
+    if (!Support.buffer)
+      throw new Error(Errors.DATATYPE_BUFFER_UNSUPPORTED);
+    return DATATYPE.BUFFER;
+  }  else if (input instanceof Blob) {
+    if (!Support.blob)
+      throw new Error(Errors.DATATYPE_BLOB_UNSUPPORTED);
+    return DATATYPE.BLOB;
+  } else if (input instanceof Uint8Array) {
+    if (!Support.uint8array)
+      throw new Error(Errors.DATATYPE_U8ARRAY_UNSUPPORTED);
+    return DATATYPE.U8ARRAY;
+  }
+  else if (input instanceof ArrayBuffer) {
+    if (!Support.arrayBuffer)
+      throw new Error(Errors.DATATYPE_ARRAYBUFFER_UNSUPPORTED);
+    return DATATYPE.ARRAYBUFFER;
+  } else {  // Add an else block to handle unsupported types
+    throw new Error(Errors.DATATYPE_UNSUPPORTED);
+  }
+};

package/src/shared/components/ZipCrypto.ts

@@ -0,0 +1,91 @@
+// ======================================
+//	ZipCrypto.ts
+//  Copyright (c) 2024 NeoWare, Inc. All rights reserved.
+// ======================================
+// Zip Cryptography Routines
+
+"use strict";
+
+import { createHash, randomFillSync } from 'crypto';
+
+import { crc32update, uMul } from './Util';
+import { ENCRYPT_HDR_SIZE } from '../constants/Headers';
+
+// Return the SHA256 hash of a buffer
+export function sha256(data: Buffer): string {
+  const hash = createHash('sha256');
+
+  return hash
+    .update(data)
+    .digest('hex');
+}
+
+class InitKeys {
+  private keys: Uint32Array;
+
+  constructor(pw: string | Buffer) {
+    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: number): number {
+    this.keys[0] = crc32update(this.keys[0], byteValue);
+    this.keys[1] = ((this.keys[1] + (this.keys[0] & 0xff)) * 0x08088405 + 1) >>> 0;
+    this.keys[2] = crc32update(this.keys[2], this.keys[1] >>> 24);
+    return byteValue;
+  }
+
+  next(): number {
+    const k = (this.keys[2] | 2) >>> 0; // key
+    return (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: string | Buffer): Function {
+  const keys = new InitKeys(pwd);
+
+  return function (data: Buffer, result: Buffer, pos: number = 0): Buffer {
+    // 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
+export function encrypter(data: Buffer | null, checkByte: number, pwd: string): Buffer | null {
+  if (!data) return null;
+
+  const _encrypter = make_encrypter(pwd);
+
+  const salt = randomFillSync(Buffer.alloc(ENCRYPT_HDR_SIZE));
+  salt[ENCRYPT_HDR_SIZE - 1] = checkByte;
+ 
+  // create encryption header
+  const result = Buffer.alloc(data.length + ENCRYPT_HDR_SIZE);
+  _encrypter(salt, result);
+
+  // encode content
+  return _encrypter(data, result, ENCRYPT_HDR_SIZE);
+}
+
+// Return the decrypter function
+export function decrypter(pwd: string | Buffer): Function {
+  const keys = new InitKeys(pwd);
+
+  return function (data: Buffer): Buffer {
+    for (let i=0; i<data.length; i++) {
+      data[i] = keys.updateKeys(data[i] ^ keys.next()); 
+    }
+    return data;
+  };
+}