neozipkit 0.1.1 → 0.3.0

package/src/{shared → core}/components/Util.ts

@@ -6,6 +6,7 @@
 
 import Support from "./Support";
 import Errors from "../constants/Errors";
+import { TIMESTAMP_SUBMITTED, TIMESTAMP_METADATA, TOKENIZED_METADATA } from "../constants/Headers";
 
 export const DATATYPE = {
   STRING: "string",
@@ -17,40 +18,6 @@ export const DATATYPE = {
   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));
@@ -111,3 +78,14 @@ export function getTypeOf(input: string|Buffer|Blob|Array<any>|ArrayBuffer|Uint8
     throw new Error(Errors.DATATYPE_UNSUPPORTED);
   }
 };
+
+/**
+ * Check if a filename is a metadata file
+ * @param filename The filename to check
+ * @returns True if the file is a metadata file (timestamp or tokenized metadata)
+ */
+export const isMetadataFile = (filename: string): boolean => {
+  return filename === TIMESTAMP_SUBMITTED || 
+         filename === TIMESTAMP_METADATA || 
+         filename === TOKENIZED_METADATA;
+};

package/src/{shared → core}/constants/Errors.ts

@@ -73,10 +73,6 @@ export default {
     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/src/{shared → core}/constants/Headers.ts

@@ -144,28 +144,30 @@ export const EXTENSIBLE_DATA_FIELDS = {
 
 // Header IDs
 export const HDR_ID = {
-  ZIP64:           0x0001,
-  AVINFO:          0x0007,
-  PFS:             0x0008,
-  OS2:             0x0009,
-  NTFS:            0x000a,
-  OPENVMS:         0x000c,
-  UNIX:            0x000d,
-  FORK:            0x000e,
-  PATCH:           0x000f,
-  x509PKCS7:       0x0014,
-  x509CERT_IDF:    0x0015,
-  x509CERT_IDC:    0x0016,
-  STRONG_ENC:      0x0017,
-  RECORD_MGT:      0x0018,
-  x509PKCS7RL:     0x0019,
-  IBM1:            0x0065,
-  IBM2:            0x0066,
+  ZIP64:           0x0001,    // ZIP64 Extended Information Extra Field
+  AVINFO:          0x0007,    // AV Info
+  PFS:             0x0008,    // PFS Extra Field
+  OS2:             0x0009,    // OS/2 Extra Field
+  NTFS:            0x000a,    // NTFS Extra Field
+  OPENVMS:         0x000c,    // OpenVMS Extra Field
+  UNIX:            0x000d,    // Unix Extra Field
+  FORK:            0x000e,    // Fork Data Extra Field
+  PATCH:           0x000f,    // Patch Descriptor Extra Field
+  x509PKCS7:       0x0014,    // X.509 Certificate Store (PKCS#7)
+  x509CERT_IDF:    0x0015,    // X.509 Certificate ID and Fingerprint
+  x509CERT_IDC:    0x0016,    // X.509 Certificate ID and Certificate
+  STRONG_ENC:      0x0017,    // Strong Encryption Header
+  RECORD_MGT:      0x0018,    // Record Management Controls
+  x509PKCS7RL:     0x0019,    // X.509 Certificate Revocation List (PKCS#7)
+  IBM1:            0x0065,    // IBM S/390 (Z390) - Attribute
+  IBM2:            0x0066,    // IBM S/390 (Z390) - Attribute
   SHA256:          0x014E,    // SHA256 "N\01" with 64 bytes (256 bit) of SHA256 hash data
   POSZIP:          0x4690,    // POSZIP 4690
   UNV_TIME:        0x5455,    // Universal Time (UT) (32-bit) 5 data bytes
   UID_GID:         0x7875,    // Unix UID/GID (any size)
   UNICODE_PATH:    0x7075,    // Info-ZIP Unicode Path Extra Field
+  SYMLINK:         0x7855,    // Unix Symbolic Link Extra Field
+  HARDLINK:        0x7865,    // Unix Hard Link Extra Field
 };
 
 // File System

package/src/core/encryption/Manager.ts

@@ -0,0 +1,137 @@
+/**
+ * Encryption Manager for NeoZipKit
+ * Manages different encryption providers and provides a unified interface
+ */
+
+import { EncryptionProvider, EncryptionOptions, EncryptionResult, DecryptionResult, EncryptionMethod } from './types';
+import { ZipCrypto } from './ZipCrypto';
+
+export class EncryptionManager {
+  private providers: Map<EncryptionMethod, EncryptionProvider> = new Map();
+
+  constructor() {
+    // Register default encryption providers
+    this.registerProvider(new ZipCrypto());
+  }
+
+  /**
+   * Register a new encryption provider
+   */
+  registerProvider(provider: EncryptionProvider): void {
+    if (provider.canHandle(EncryptionMethod.ZIP_CRYPTO)) {
+      this.providers.set(EncryptionMethod.ZIP_CRYPTO, provider);
+    }
+  }
+
+  /**
+   * Get available encryption methods
+   */
+  getAvailableMethods(): EncryptionMethod[] {
+    return Array.from(this.providers.keys());
+  }
+
+  /**
+   * Get encryption provider for a specific method
+   */
+  getProvider(method: EncryptionMethod): EncryptionProvider | null {
+    return this.providers.get(method) || null;
+  }
+
+  /**
+   * Encrypt data using specified method
+   */
+  async encrypt(data: Buffer, options: EncryptionOptions): Promise<EncryptionResult> {
+    const provider = this.getProvider(options.method);
+    if (!provider) {
+      return {
+        success: false,
+        error: `No encryption provider available for method ${options.method}`
+      };
+    }
+
+    return await provider.encrypt(data, options);
+  }
+
+  /**
+   * Decrypt data using specified method
+   */
+  async decrypt(data: Buffer, options: EncryptionOptions): Promise<DecryptionResult> {
+    const provider = this.getProvider(options.method);
+    if (!provider) {
+      return {
+        success: false,
+        error: `No decryption provider available for method ${options.method}`
+      };
+    }
+
+    return await provider.decrypt(data, options);
+  }
+
+  /**
+   * Get recommended encryption method (ZIP_CRYPTO)
+   */
+  getRecommendedMethod(): EncryptionMethod {
+    return EncryptionMethod.ZIP_CRYPTO;
+  }
+
+  /**
+   * Validate encryption options
+   */
+  validateOptions(options: EncryptionOptions): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!options.method) {
+      errors.push('Encryption method is required');
+    }
+
+    if (!options.password || options.password.length === 0) {
+      errors.push('Password is required');
+    }
+
+    if (options.password && options.password.length < 4) {
+      errors.push('Password must be at least 4 characters long');
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors: errors
+    };
+  }
+
+  /**
+   * Get encryption method info
+   */
+  getMethodInfo(method: EncryptionMethod): { name: string; keyLength: number; secure: boolean } | null {
+    const provider = this.getProvider(method);
+    if (!provider) {
+      return null;
+    }
+
+    return {
+      name: provider.getMethodName(),
+      keyLength: provider.getKeyLength(),
+      secure: false
+    };
+  }
+
+  /**
+   * List all available encryption methods with their details
+   */
+  listMethods(): Array<{ method: EncryptionMethod; name: string; keyLength: number; secure: boolean }> {
+    const methods: Array<{ method: EncryptionMethod; name: string; keyLength: number; secure: boolean }> = [];
+    
+    for (const [method, provider] of this.providers) {
+      methods.push({
+        method: method,
+        name: provider.getMethodName(),
+        keyLength: provider.getKeyLength(),
+        secure: false
+      });
+    }
+
+    return methods.sort((a, b) => {
+      // Sort by name
+      return a.name.localeCompare(b.name);
+    });
+  }
+}