neozipkit 0.1.1

package/examples/unzip-token.ts

@@ -0,0 +1,488 @@
+#!/usr/bin/env node
+
+// ======================================
+//	unzip-token.ts
+//  A command-line utility for extracting and managing ZIP archives with advanced features
+//  including decryption, blockchain token verification, and SHA-256 validation.
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import { exit } from 'process';
+import * as fs from 'fs';
+import * as path from 'path';
+import readline from 'readline';
+import moment from 'moment-timezone';
+
+import { 
+  NEOZIPKIT_INFO,
+  ZipKitServer, 
+  ZipEntry, 
+  TIMESTAMP_METADATA, 
+  TIMESTAMP_SUBMITTED, 
+  verifyTimestamp 
+} from 'neozipkit';
+
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { sprintf } from 'sprintf-js';
+
+// Import blockchain components for token verification
+import { NZipTokenInfo } from './blockchain/types';
+import { TOKENIZED_METADATA } from '../src/constants/Headers';
+
+// Import token verification functionality
+import { 
+  checkForTokenization, 
+  TokenVerificationOptions 
+} from './blockchain/TokenVerifier';
+
+// Add NeoUnzip version constants
+const NEOUNZIP_VERSION = '0.1.2';
+const NEOUNZIP_RELEASE_DATE = '03-31-2025';
+
+// Display copyright and version header on startup
+console.log(`NeoUnzip v${NEOUNZIP_VERSION} (${NEOUNZIP_RELEASE_DATE})  Copyright (c) 2025 NeoWare, Inc. All rights reserved`);
+console.log(`Using NeoZipKit v${NEOZIPKIT_INFO.version} (${NEOZIPKIT_INFO.releaseDate})`);
+
+const options = yargs(hideBin(process.argv))
+  .usage("Usage: $0 <zipfile> <extract path>")
+  .demandCommand(1, "Error - The .zip filename is required.")
+  .option('t', { alias: 'test', describe: 'Test archive files', type: 'boolean' })
+  .option('u', { alias: 'update', describe: 'Update files, create if neccessary', type: 'boolean' })
+  .option('f', { alias: 'freshen', describe: 'Freshen by extracting only if older file on disk.', type: 'boolean' })
+  .option('d', { alias: 'directory', describe: 'Specify a different directory', type: 'string' })
+  .option('x', { alias: 'exclude', describe: 'Exclude specified files', type: 'array' })
+  .option('j', { alias: 'junk', describe: 'Junk paths (don\'t make directories)', type: 'boolean' })
+  .option('q', { alias: 'quiet', describe: 'Quiet mode', type: 'boolean' })
+  .option('o', { alias: 'overwrite', describe: 'Overwrite files without prompting', type: 'boolean' })
+  .option('n', { alias: 'never', describe: 'Never overwrite existing files', type: 'boolean' })
+  .option('L', { alias: 'license', describe: 'Display software license', type: 'boolean' })
+  .option('H', { alias: 'Hash SHA-256', describe: 'Calculate and validate SHA-256 Hash on entries', type: 'boolean' })
+  .option('skip-hash', { describe: 'Skip SHA-256 hash validation', type: 'boolean' })
+  .option('skip-token', { describe: 'Skip NFT token verification', type: 'boolean' })
+  .option('S', { alias: 'Skip Timestamp', describe: 'Do not validate timestamped Zip', type: 'boolean' })
+  .option('C', { alias: 'Timestamp Certificate HTML', describe: 'Create a timestamp certicate as HTML file', type: 'boolean' })
+  .option('P', { alias: 'Timestamp Certificate PDF', describe: 'Create a timestamp certicate as PDF file', type: 'boolean' })
+  .option('c', { alias: 'certificate', describe: 'Generate token certificate', type: 'boolean' })
+  .help('help', 'Show help').alias('help', 'h')
+  .wrap(null)
+  .epilog('Copyright (c) 2025 NeoWare, Inc. - Type "neounzip "-L" for software license.\n')
+  .parseSync()
+
+const zipFile = options._[0] as string;
+const zipKit = new ZipKitServer();
+
+// Global variables for token verification
+let isTokenizedZip = false;
+let tokenMetadata: NZipTokenInfo | null = null;
+let calculatedMerkleRoot: string | null = null;
+
+async function main() {
+try {
+  // Check if the file exists before trying to read it
+  if (!fs.existsSync(zipFile)) {
+    console.error(`Error: Zip file "${zipFile}" does not exist`);
+    exit(1);
+  }
+  
+  const inBuffer = fs.readFileSync(zipFile);
+  zipKit.loadZip(inBuffer);
+    
+    // Check if this is a tokenized ZIP file
+    const verificationOptions: TokenVerificationOptions = {
+      skipHash: options['skip-hash'],
+      skipToken: options['skip-token'],
+      generateCertificate: options.c,
+      zipFileName: zipFile
+    };
+    
+    const result = await checkForTokenization(zipKit, verificationOptions);
+    
+    // Update global variables with results
+    isTokenizedZip = result.isTokenized;
+    tokenMetadata = result.tokenMetadata;
+    calculatedMerkleRoot = result.calculatedMerkleRoot;
+    
+} catch (error) {
+  console.error(`Error: Failed to read zip file "${zipFile}"`);
+  console.error(error);
+  exit(1);
+}
+
+// command options
+if (options.t) {
+  // Test the CRC of the zip file
+    await extractFiles(true);
+} else if (options.z) {
+  // Archive comment onlyzip
+} else if (options.L) {
+  displayLicense();
+} else {
+  // No options, extract all files
+    await extractFiles(false)
+  }
+}
+
+// Start the main function
+main().catch(error => {
+  console.error('Unhandled error:', error);
+  exit(1);
+});
+
+// Display the software license
+function displayLicense() {
+  prt('Copyright (c) 2025 by NeoWare, Inc.  All rights reserved\n');
+  exit(0);
+}
+
+/**
+ * Extracts or tests files from the ZIP archive
+ * @param test - If true, only tests archive integrity without extracting
+ */
+async function extractFiles(test: boolean = false) {
+  try {
+    let zipEntries = zipKit.getDirectory() as ZipEntry[];
+    
+    // Check if we have any entries
+    if (!zipEntries || zipEntries.length === 0) {
+      console.log('\nArchive is empty or invalid: ', zipFile);
+      return;
+    }
+    
+    let zipComment = zipKit.getZipComment();
+
+    console.log('\nArchive: ', zipFile);
+    if (zipComment)
+      console.log(zipComment);
+
+    let _extFiles = 0;
+    let _total = 0;
+    let _cmpTotal = 0;
+    let _password = null;
+    let _localData = null;
+    let _metaStamp = null;
+    for (const entry of zipEntries) {
+      // Check if Zip Entry is encrypted
+      if (entry.isEncrypted) {
+        if (entry.isStrongEncrypt) {
+          prt(sprintf("   skipping: %-25s Strong Encryption not supported\n", entry.filename));
+          continue;
+        }
+        for (var i=0; i < 3; i++) {
+          if (_password == null) {
+            _password = await inputPassword(entry, i > 0);
+          }
+          _localData = zipKit.decryptEntry(entry, _password);
+          if (_localData) break;
+          _password = null;
+        }
+        if (!_localData) {
+          prt(sprintf("   skipping: %-25s incorrect password\n", entry.filename));
+          continue;
+        }
+      }
+
+      test ? prt(sprintf("   Testing: %-25s  ", entry.filename)) : 
+             prt(sprintf("   Extracting: %-25s  ", entry.filename));
+      try {
+        let _outBuf = await zipKit.extract(entry);
+
+        if (entry.filename === TIMESTAMP_METADATA) {
+          _metaStamp = _outBuf;
+          console.log('  Timestamp Metadata');
+          continue;
+        } else if (entry.filename === TIMESTAMP_SUBMITTED) {
+          _metaStamp = _outBuf;
+          console.log('  Timestamp Submitted');
+          continue;
+        } else if (entry.filename === TOKENIZED_METADATA) {
+          console.log('  NFT Token Metadata (not extracted)');
+          continue;
+        } else if (!test) {
+          const _path = options.d ? options.d + path.sep + entry.filename : entry.filename;
+          const _overwrite = await testOverwrite(_path);
+          if (_overwrite) {
+            if (_outBuf) {
+              writeFile(_path, _outBuf, entry, entry.extFileAttr);
+            } else {
+              prt("Error: No data to write\n");
+              continue;
+            }
+          } else if (options.n) {
+            prt("file exists, Skipped\n");
+            continue;
+          } else {
+            prt("  Skipped\n");
+            continue;
+          }
+        }
+
+        // Automatically validate SHA-256 if available and not skipped
+        if (entry.sha256 && !options['skip-hash']) {
+          console.log('  OK SHA-256 ✅');
+        } else if (entry.sha256 && options['skip-hash']) {
+          console.log('  OK (SHA-256 skipped)');
+        } else {
+          console.log('  OK');
+        }
+
+        _extFiles++;
+        _total += entry.uncompressedSize;
+        _cmpTotal += entry.compressedSize;
+      } catch (e) {
+        prt("  Failed\n");
+        console.log(e);
+      }
+    };
+    console.log('No Errors where detected in %d files %s.', _extFiles, test ? 'tested' : 'extracted');
+    
+    // Display token verification results if this is a tokenized ZIP
+    if (isTokenizedZip && tokenMetadata) {
+      console.log('\n🔗 Token Verification Summary:');
+      console.log('═'.repeat(50));
+      
+      // Full NFT token info only
+      console.log(`Token ID: ${tokenMetadata.tokenId}`);
+      console.log(`Network: ${tokenMetadata.network}`);
+      console.log(`Contract: ${tokenMetadata.contractAddress}`);
+      
+      if (options['skip-token']) {
+        console.log('⏭️  Token verification: SKIPPED');
+      } else if (options['skip-hash']) {
+        console.log('⏭️  Archive integrity: SKIPPED');
+        console.log('   Hash calculation disabled - cannot verify');
+      } else if (calculatedMerkleRoot) {
+        console.log('🌐 Archive integrity: BLOCKCHAIN VERIFIED');
+        console.log('   See verification details above');
+      } else {
+        console.log('⚠️  Archive integrity: CANNOT VERIFY');
+        console.log('   Unable to calculate merkle root for comparison');
+      }
+      console.log('═'.repeat(50));
+    }
+
+    let _merkleRoot = zipKit.checkForTimestamp();
+    if (_merkleRoot) {
+      if (options.S) {
+        console.log('Archive contains timestamp metadata - Skipping Validation');
+        return;
+      }
+      console.log('Archive is timestamped - Pending Validation');
+      if (!_merkleRoot) {
+        console.log('No timestamp metadata found');
+        console.log('Archive timestamp validation failed!');
+      } else {
+        // Validate the timestamp
+        let _ots = await zipKit.getOts();
+        const _timestampResult = await verifyTimestamp(_merkleRoot, _ots);
+        
+        // First check if _timestampResult is not null
+        if (_timestampResult) {
+          // Type guard to check if we have a successful result with the verified property
+          if ('verified' in _timestampResult && _timestampResult.verified) {
+            // Check if results property exists
+            if ('results' in _timestampResult && _timestampResult.results) {
+              for (const chain in _timestampResult.results) {
+                let _results = _timestampResult.results[chain];
+                const _date = moment(_results.timestamp * 1000).tz(moment.tz.guess()).format('MM-DD-YYYY hh:mma z');
+                const _blockchain = chain.charAt(0).toUpperCase() + chain.slice(1);
+                console.log('Success! ' + _blockchain + ' block ' + _results.height + ' attests existence as of ' + _date);
+              }
+            }
+            
+            // Check if upgradedOts property exists
+            if ('upgradedOts' in _timestampResult && _timestampResult.upgradedOts) {
+              const upgrade = await askUpgrade();
+              if (upgrade) {
+                let upgradeBuf = Buffer.from(_timestampResult.upgradedOts);
+                await zipKit.upgradeOTS(zipFile, upgradeBuf);
+                console.log('OTS upgraded - Certificate generation is now possible');
+              } else {
+                console.log('Certificate generation is not possible until timestamp is validated');
+              }
+            }
+          } else if ('error' in _timestampResult && !_timestampResult.error) {
+            console.log('Archive timestamp awaiting submittion to blockchain');
+            if (options.C || options.P) {
+              console.log('Certificate generation is not possible until timestamp is validated');
+            }
+          }
+        } else {
+          console.log('No timestamp information available');
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error processing zip file:', error);
+    exit(1);
+  }
+}
+
+/**
+ * Writes an extracted file to disk
+ * @param filename - Path where the file should be written
+ * @param outBuf - Buffer containing file data
+ * @param entry - ZIP entry associated with the file
+ * @param fileAttr - Optional Unix file permissions
+ * @returns boolean indicating success
+ */
+function writeFile(filename: string, outBuf: Buffer, entry?: ZipEntry, fileAttr?: number | undefined) {
+  // get Unix file permissions
+  const _fattr = fileAttr ? (((fileAttr >>> 0) | 0) >> 16) & 0xfff : 0; 
+
+  var fd;
+  try {
+    fd = fs.openSync(filename, "w", 438); // 0666
+  } catch (e) {
+    fs.chmodSync(filename, 438);
+    fd = fs.openSync(filename, "w", 438);
+  }
+  if (!fd) return false;
+
+  try {
+    fs.writeSync(fd, outBuf, 0, outBuf.length, 0);
+  } finally {
+    fs.closeSync(fd);
+  }
+
+  if (_fattr)
+    fs.chmodSync(filename, _fattr);
+    
+  // Set file modification time if universal time is available
+  if (entry && entry.universalTime) {
+    const mtime = new Date(entry.universalTime * 1000); // Convert Unix timestamp (seconds) to milliseconds
+    try {
+      // Set both access time and modification time to the universal time
+      fs.utimesSync(filename, mtime, mtime);
+    } catch (e) {
+      console.error(`Warning: Could not set file time for ${filename}: ${e}`);
+    }
+  }
+  
+  // Set owner and group if UID and GID are available (Unix-like systems only)
+  if (entry && (entry.uid !== null || entry.gid !== null)) {
+    try {
+      // Use process functions as fallbacks if they exist (Unix-like systems)
+      // Default to 0 (root) if neither entry values nor process functions are available
+      const uid = entry.uid !== null ? entry.uid : 
+                  (typeof process.getuid === 'function' ? process.getuid() : 0);
+      const gid = entry.gid !== null ? entry.gid : 
+                  (typeof process.getgid === 'function' ? process.getgid() : 0);
+      
+      // Change owner and group of the file
+      fs.chownSync(filename, uid, gid);
+    } catch (e) {
+      // This might fail on Windows or if user doesn't have permission
+      console.error(`Warning: Could not set owner/group for ${filename}: ${e}`);
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Checks if a file should be overwritten during extraction
+ * @param filename - Path of the file to check
+ * @returns Promise<boolean> indicating if file should be overwritten
+ */
+async function testOverwrite(filename: string): Promise<boolean> {
+  // Check if we need to create a new folder
+  const _folder = path.dirname(filename);
+  if (!fs.existsSync(_folder)) {
+    console.log('Need to create directory: ', _folder);
+    // makeDir(_folder);
+  }
+  
+  const _stat = fs.statSync(filename);
+  if (_stat.isDirectory()) {
+    console.log(': ', filename);
+    return false;
+  }
+
+  if (!fs.existsSync(filename)) 
+    return true;
+
+  if (options.n) {
+    return false;
+  } else if (options.o) {
+    return true;
+  }
+
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.write("file exists, Overwrite? (y/n/a): ");
+
+    process.stdin.once('data', (data: Buffer) => {
+      const char = data.toString().toLowerCase();
+      
+      // Restore stdin to its previous state
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write(char);
+
+      if (char === 'y') {
+        resolve(true);
+      } else if (char === 'a') {
+        prt("  Aborted\n");
+        exit(0);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+/**
+ * Prompts user to confirm timestamp upgrade
+ * @returns Promise<boolean> indicating user's choice
+ */
+async function askUpgrade(): Promise<boolean> {
+  return new Promise((resolve) => {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdout.write("Upgrade NeoTimestamp? (y/n): ");
+
+    process.stdin.once('data', (data: Buffer) => {
+      const char = data.toString().toLowerCase();
+      
+      // Restore stdin to its previous state
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write(char + '\n');
+
+      if (char === 'y') {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+/**
+ * Prompts for password when extracting encrypted files
+ * @param entry - ZIP entry requiring password
+ * @param retry - Boolean indicating if this is a retry attempt
+ * @returns Promise<string> containing the entered password
+ */
+async function inputPassword(entry: ZipEntry, retry: boolean): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+
+  return new Promise<string>((resolve) => {
+    rl.question(retry ?
+        'password incorrect - renter: ' :
+        `[${zipFile}] ${entry.filename} password: `, (input: string) => {
+      rl.close();
+      resolve(input);
+    });
+  });
+}
+
+function prt(msg: string) {
+  process.stdout.write(msg);
+}