stegdoc 6.0.0 → 6.1.0

package/src/commands/encode.js

@@ -3,14 +3,13 @@ const fs = require('fs');
 const { pipeline } = require('stream/promises');
 const chalk = require('chalk');
 const ora = require('ora');
-const AdmZip = require('adm-zip');
-const { createDocxWithBase64, createDocxV5 } = require('../lib/docx-handler');
+const { createDocxV5 } = require('../lib/docx-handler');
 const { createXlsxPartV5 } = require('../lib/xlsx-handler');
 const { createMetadata, serializeMetadata } = require('../lib/metadata');
 const crypto = require('crypto');
 const { generateHash, parseSizeToBytes, formatBytes, generateFilename } = require('../lib/utils');
 const { packEncryptionMeta, generateSalt, createEncryptStream } = require('../lib/crypto');
-const { isCompressedMime, createCompressStream, createBrotliCompressStream } = require('../lib/compression');
+const { createBrotliCompressStream } = require('../lib/compression');
 const { resetTimeWindow } = require('../lib/decoy-generator');
 const { resetTimeState, BYTES_PER_DATA_LINE, calculateDataLineCount } = require('../lib/log-generator');
 const { shouldRunInteractive, promptEncodeOptions } = require('../lib/interactive');
@@ -18,12 +17,52 @@ const { BinaryChunkCollector, ProgressTransform } = require('../lib/streams');
 const { loadNative } = require('../lib/native');
 
 /**
- * Zip a folder into a buffer
+ * Load the native engine, failing loudly when it is unavailable. Bundling has
+ * no JavaScript implementation any more: the archive is built by the core.
+ *
+ * @returns {object} The native binding.
+ */
+function requireNative() {
+  const native = loadNative();
+  if (!native || typeof native.zip !== 'function') {
+    throw new Error(
+      'Bundling inputs requires the native engine, which is not installed. ' +
+      'Reinstall stegdoc, or build it with `pnpm build:native`.'
+    );
+  }
+  return native;
+}
+
+/**
+ * Recursively collect a directory's files as archive entries under `prefix`.
+ *
+ * @param {string} dirPath Directory to walk.
+ * @param {string} prefix Forward-slash entry path prefix.
+ * @param {Array<{name: string, bytes: Buffer}>} entries Accumulator.
+ */
+function collectDirectory(dirPath, prefix, entries) {
+  for (const dirent of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const full = path.join(dirPath, dirent.name);
+    const name = `${prefix}/${dirent.name}`;
+    if (dirent.isDirectory()) {
+      collectDirectory(full, name, entries);
+    } else {
+      entries.push({ name, bytes: fs.readFileSync(full) });
+    }
+  }
+}
+
+/**
+ * Zip a folder into a buffer, keeping the folder's basename as a prefix.
+ *
+ * @param {string} folderPath Folder to archive.
+ * @returns {Buffer} The archive bytes.
  */
 function zipFolder(folderPath) {
-  const zip = new AdmZip();
-  zip.addLocalFolder(folderPath);
-  return zip.toBuffer();
+  const native = requireNative();
+  const entries = [];
+  collectDirectory(folderPath, path.basename(folderPath), entries);
+  return native.zip(entries);
 }
 
 /**
@@ -59,18 +98,19 @@ function uniqueEntryName(name, used) {
  * @returns {Buffer} The archive bytes.
  */
 function zipInputs(inputs) {
-  const zip = new AdmZip();
+  const native = requireNative();
+  const entries = [];
   const used = new Set();
   for (const input of inputs) {
     const base = path.basename(input.replace(/[\\/]+$/, ''));
     const entry = uniqueEntryName(base, used);
     if (fs.statSync(input).isDirectory()) {
-      zip.addLocalFolder(input, entry);
+      collectDirectory(input, entry, entries);
     } else {
-      zip.addLocalFile(input, '', entry);
+      entries.push({ name: entry, bytes: fs.readFileSync(input) });
     }
   }
-  return zip.toBuffer();
+  return native.zip(entries);
 }
 
 /**
@@ -86,21 +126,23 @@ function bundleFilename(name) {
 }
 
 /**
- * Detect file type from the first 4KB
+ * Extensions whose contents are already compressed, so Brotli only wastes CPU.
  */
-async function detectFileType(filePath) {
-  try {
-    const fileType = await import('file-type');
-    const fromBuffer = fileType.fileTypeFromBuffer || fileType.default?.fromBuffer;
-    if (!fromBuffer) return null;
-    const fd = await fs.promises.open(filePath, 'r');
-    const buf = Buffer.alloc(4100);
-    await fd.read(buf, 0, 4100, 0);
-    await fd.close();
-    return await fromBuffer(buf);
-  } catch {
-    return null;
-  }
+const COMPRESSED_EXTENSIONS = new Set([
+  'zip', 'gz', 'tgz', 'bz2', 'xz', '7z', 'rar',
+  'jpg', 'jpeg', 'png', 'gif', 'webp',
+  'mp3', 'mp4', 'm4a', 'mov', 'avi', 'mkv', 'webm', 'ogg', 'opus', 'flac',
+  'pdf', 'apk', 'jar', 'docx', 'xlsx', 'pptx', 'wasm', 'br',
+]);
+
+/**
+ * Check whether an extension is already compressed.
+ *
+ * @param {string} ext Extension, with or without a leading dot.
+ * @returns {boolean} True when the format needs no further compression.
+ */
+function isCompressedExtension(ext) {
+  return COMPRESSED_EXTENSIONS.has(String(ext || '').toLowerCase().replace(/^\./, ''));
 }
 
 /**
@@ -143,13 +185,9 @@ async function encodeCommand(input, options) {
   }
 
   const quiet = options.quiet || false;
-  const legacy = options.legacy || false;
   if (options.v5 && options.v6) {
     throw new Error('--v5 and --v6 cannot be combined.');
   }
-  if (legacy && (options.v5 || options.v6)) {
-    throw new Error('--legacy cannot be combined with --v5 or --v6.');
-  }
   const version = options.v5 ? 'v5' : 'v6';
   const spinner = quiet ? { start: () => {}, succeed: () => {}, fail: () => {}, info: () => {}, text: '' } : ora('Starting encoding process...').start();
   const createdFiles = [];
@@ -220,33 +258,22 @@ async function encodeCommand(input, options) {
 
     spinner.text = 'Checking file type...';
     let useCompression = true;
-    const fileType = await detectFileType(streamSource);
+    const extensionKey = extension.replace(/^\./, '').toLowerCase();
 
-    if (fileType && isCompressedMime(fileType.mime)) {
+    if (isCompressedExtension(extensionKey)) {
       useCompression = false;
-      spinner.info && spinner.info(`Skipping compression (${fileType.ext} is already compressed)`);
+      spinner.info && spinner.info(`Skipping compression (${extensionKey} is already compressed)`);
     }
 
-    // DOCX v5 size limit (not applicable in legacy mode or with --no-limit)
+    // DOCX v5 size limit (not applicable with --no-limit)
     const noLimit = options.noLimit || options.limit === false;
-    if (format === 'docx' && !legacy && !noLimit && fileSize > 1 * 1024 * 1024) {
+    if (format === 'docx' && !noLimit && fileSize > 1 * 1024 * 1024) {
       throw new Error(
         `DOCX format is limited to files under 1 MB (yours is ${formatBytes(fileSize)}). ` +
         `Use XLSX format (-f xlsx) for larger files, or --no-limit to bypass.`
       );
     }
 
-    // Route to legacy or v5 pipeline
-    if (legacy) {
-      if (format === 'docx') {
-        await encodeLegacyDocx(streamSource, filename, extension, fileSize, options, useCompression, useEncryption, spinner, quiet, createdFiles);
-      } else {
-        throw new Error('Legacy XLSX format (--legacy) is no longer supported. Use v5 format (default) or legacy DOCX (-f docx --legacy).');
-      }
-      if (tempZipPath) cleanupTemp(tempZipPath);
-      return;
-    }
-
     // === Log-Embed Pipeline ===
     const hash = generateHash();
     const outputDir = options.outputDir || process.cwd();
@@ -274,7 +301,7 @@ async function encodeCommand(input, options) {
     // Pre-compute content hash
     spinner.text = 'Computing file hash...';
 
-    // Prefer the native engine. Legacy mode returned above.
+    // Prefer the native engine; the JavaScript encoder only covers v5.
     const native = loadNative();
     if (version === 'v6' && !native) {
       throw new Error(
@@ -393,7 +420,6 @@ async function encodeCommand(input, options) {
         encrypted: useEncryption,
         compressed: useCompression,
         contentHash,
-        stegoMethod: 'log-embed',
         compressionAlgo: 'brotli',
         payloadSize: payloadBuffer.length,
         dataLineCount,
@@ -497,96 +523,6 @@ async function encodeCommand(input, options) {
   }
 }
 
-// ─── Legacy v4 DOCX Pipeline ────────────────────────────────────────────────
-
-async function encodeLegacyDocx(inputPath, filename, extension, fileSize, options, useCompression, useEncryption, spinner, quiet, createdFiles) {
-  const { compress } = require('../lib/compression');
-  const { encrypt, packEncryptionMeta: packMeta } = require('../lib/crypto');
-  const { generateContentHash } = require('../lib/utils');
-
-  const fileBuffer = fs.readFileSync(inputPath);
-  const contentHash = generateContentHash(fileBuffer);
-
-  let processedBuffer = fileBuffer;
-  if (useCompression) {
-    spinner.text = 'Compressing...';
-    const compressedBuffer = await compress(fileBuffer);
-    if (compressedBuffer.length < fileBuffer.length) {
-      processedBuffer = compressedBuffer;
-      spinner.succeed && spinner.succeed(`Compressed: ${formatBytes(fileBuffer.length)} → ${formatBytes(compressedBuffer.length)}`);
-    } else {
-      useCompression = false;
-      spinner.info && spinner.info('Compression skipped (no size benefit)');
-    }
-  }
-
-  const base64 = processedBuffer.toString('base64');
-
-  let contentToStore;
-  let encryptionMeta = null;
-
-  if (useEncryption) {
-    spinner.text = 'Encrypting content...';
-    const { ciphertext, iv, salt, authTag } = encrypt(base64, options.password);
-    encryptionMeta = packMeta({ iv, salt, authTag });
-    contentToStore = ciphertext;
-    spinner.succeed && spinner.succeed('Content encrypted with AES-256-GCM');
-  } else {
-    contentToStore = base64;
-  }
-
-  const hash = generateHash();
-  const outputDir = options.outputDir || process.cwd();
-  const format = 'docx';
-
-  const metadata = createMetadata({
-    originalFilename: filename,
-    originalExtension: extension,
-    hash,
-    partNumber: null,
-    totalParts: null,
-    originalSize: fileSize,
-    format,
-    encrypted: useEncryption,
-    compressed: useCompression,
-    contentHash,
-  });
-
-  const outputFilename = generateFilename(hash, null, null, format);
-  const outputPath = path.join(outputDir, outputFilename);
-
-  if (fs.existsSync(outputPath) && !options.force) {
-    throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
-  }
-
-  const docxContent = useEncryption
-    ? `${encryptionMeta}|||${contentToStore}`
-    : contentToStore;
-
-  await createDocxWithBase64({
-    base64Content: docxContent,
-    metadata,
-    outputPath,
-  });
-
-  createdFiles.push(outputPath);
-  spinner.succeed && spinner.succeed('Encoding complete!');
-
-  if (!quiet) {
-    console.log();
-    console.log(chalk.green.bold('✓ File encoded successfully!'));
-    console.log(chalk.cyan(`  Format: DOCX (v4 legacy)`));
-    console.log(chalk.cyan(`  Hash: ${hash}`));
-    console.log(chalk.cyan(`  Output: ${outputFilename}`));
-    console.log(chalk.cyan(`  Encrypted: ${useEncryption ? 'Yes' : 'No'}`));
-    console.log(chalk.cyan(`  Compressed: ${useCompression ? 'Yes' : 'No'}`));
-    console.log(chalk.cyan(`  Location: ${outputDir}`));
-    if (useEncryption) {
-      console.log(chalk.yellow(`  Remember your password - it cannot be recovered!`));
-    }
-  }
-}
-
 function cleanupTemp(tempPath) {
   try {
     if (fs.existsSync(tempPath)) {

package/src/commands/info.js

@@ -1,13 +1,15 @@
-const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
-const { readDocxBase64 } = require('../lib/docx-handler');
-const { readXlsxBase64 } = require('../lib/xlsx-handler');
-const { validateMetadata, isMultiPart, isLogEmbedFormat } = require('../lib/metadata');
-const { detectFormat, formatBytes } = require('../lib/utils');
-const { extractContent, findMultiPartFiles } = require('../lib/file-utils');
+const { formatBytes } = require('../lib/utils');
 const { loadNative } = require('../lib/native');
 
+const NATIVE_REQUIRED =
+  'Reading file metadata requires the native engine, which is not installed. ' +
+  'Reinstall stegdoc, or build it with `pnpm build:native`.';
+
+const LEGACY_UNSUPPORTED =
+  'The legacy v3/v4 format is no longer supported. Re-encode the file with a current version of stegdoc.';
+
 /**
  * Print metadata read by the native engine, which handles v5 and v6.
  */
@@ -54,109 +56,29 @@ async function infoCommand(inputFile, options) {
   const spinner = ora('Reading file metadata...').start();
 
   try {
-    const format = detectFormat(inputFile);
-    if (!format) {
-      throw new Error('Unknown file format. Supported formats: .xlsx, .docx');
-    }
-
-    // The native engine reads v5 and v6; the JS reader only knows v5.
     const native = loadNative();
-    if (native && native.probe(inputFile) === 'v5') {
-      const info = native.info(inputFile);
-      spinner.succeed('File metadata read successfully');
-      printNativeInfo(info);
-      return;
-    }
-
-    let readResult;
-    if (format === 'xlsx') {
-      readResult = await readXlsxBase64(inputFile);
-    } else {
-      readResult = await readDocxBase64(inputFile);
-    }
-
-    const extracted = extractContent(readResult, format);
-    const metadata = extracted.metadata;
-    const encryptionMeta = extracted.encryptionMeta;
-
-    validateMetadata(metadata);
-
-    const isEncrypted = metadata.encrypted || (encryptionMeta && encryptionMeta.length > 0);
-    const isCompressed = metadata.compressed || false;
-    const isV5 = isLogEmbedFormat(metadata);
-
-    spinner.succeed('File metadata read successfully');
-    console.log();
-
-    console.log(chalk.bold.white('File Information:'));
-    console.log(chalk.cyan(`  Format: ${format.toUpperCase()}`));
-    console.log(chalk.cyan(`  Tool version: ${metadata.version || '1.x'}`));
-    if (isV5) {
-      console.log(chalk.cyan(`  Stego method: Log-embed (v5)`));
-      console.log(chalk.cyan(`  Compression: ${metadata.compressionAlgo || 'brotli'}`));
+    if (!native) {
+      throw new Error(NATIVE_REQUIRED);
     }
-    console.log();
-
-    console.log(chalk.bold.white('Original File:'));
-    console.log(chalk.cyan(`  Filename: ${metadata.originalFilename}`));
-    console.log(chalk.cyan(`  Extension: ${metadata.originalExtension}`));
-    console.log(chalk.cyan(`  Size: ${formatBytes(metadata.originalSize)}`));
-    console.log();
-
-    console.log(chalk.bold.white('Encoding Options:'));
-    console.log(chalk.cyan(`  Encrypted: ${isEncrypted ? chalk.yellow('Yes') : 'No'}`));
-    console.log(chalk.cyan(`  Compressed: ${isCompressed ? chalk.green('Yes') : 'No'}`));
-    console.log(chalk.cyan(`  Encoded on: ${metadata.encodingDate || 'Unknown'}`));
 
-    if (metadata.contentHash) {
-      console.log(chalk.cyan(`  Content hash: ${metadata.contentHash.slice(0, 16)}...`));
+    let probe;
+    try {
+      probe = native.probe(inputFile);
+    } catch {
+      probe = 'unknown';
     }
-
-    if (isV5 && metadata.dataLineCount) {
-      console.log(chalk.cyan(`  Data lines: ${metadata.dataLineCount}`));
-    }
-    console.log();
-
-    const hasMultipleParts = isMultiPart(metadata) || metadata.partNumber !== null;
-    if (hasMultipleParts) {
-      console.log(chalk.bold.white('Multi-part File:'));
-      const inputDir = path.dirname(inputFile);
-      const allParts = findMultiPartFiles(inputDir, metadata.hash, format);
-      const totalParts = metadata.totalParts || allParts.length;
-
-      console.log(chalk.cyan(`  This is part: ${metadata.partNumber} of ${totalParts}`));
-      console.log(chalk.cyan(`  Hash: ${metadata.hash}`));
-
-      console.log();
-      console.log(chalk.bold.white('Parts found in directory:'));
-
-      for (let i = 1; i <= totalParts; i++) {
-        const part = allParts.find(p => p.partNumber === i);
-        if (part) {
-          console.log(chalk.green(`  ✓ Part ${i}: ${part.filename}`));
-        } else {
-          console.log(chalk.red(`  ✗ Part ${i}: MISSING`));
-        }
-      }
-
-      if (allParts.length >= totalParts) {
-        console.log();
-        console.log(chalk.green.bold('All parts found - ready to decode'));
-      } else {
-        console.log();
-        console.log(chalk.yellow.bold(`Missing ${totalParts - allParts.length} part(s)`));
-      }
-    } else {
-      console.log(chalk.bold.white('Single File:'));
-      console.log(chalk.cyan(`  Hash: ${metadata.hash}`));
-      console.log();
-      console.log(chalk.green.bold('Ready to decode'));
+    if (probe === 'legacy') {
+      throw new Error(LEGACY_UNSUPPORTED);
     }
-
-    if (isEncrypted) {
-      console.log(chalk.yellow('\nNote: Password required for decoding'));
+    if (probe !== 'v5' && probe !== 'archive') {
+      throw new Error(
+        'Unknown file format. Supported formats: .xlsx, .docx, or a zip of them'
+      );
     }
 
+    const info = native.info(inputFile);
+    spinner.succeed('File metadata read successfully');
+    printNativeInfo(info);
   } catch (error) {
     spinner.fail('Failed to read file info');
     console.error(chalk.red(`Error: ${error.message}`));

package/src/commands/verify.js

@@ -1,14 +1,15 @@
-const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
-const { readDocxBase64 } = require('../lib/docx-handler');
-const { readXlsxBase64 } = require('../lib/xlsx-handler');
-const { validateMetadata, isMultiPart, isStreamingFormat, isLogEmbedFormat } = require('../lib/metadata');
-const { detectFormat, formatBytes } = require('../lib/utils');
-const { decrypt, unpackEncryptionMeta, createDecryptStream } = require('../lib/crypto');
-const { extractContent, findMultiPartFiles } = require('../lib/file-utils');
+const { formatBytes } = require('../lib/utils');
 const { loadNative } = require('../lib/native');
 
+const NATIVE_REQUIRED =
+  'Verifying a file requires the native engine, which is not installed. ' +
+  'Reinstall stegdoc, or build it with `pnpm build:native`.';
+
+const LEGACY_UNSUPPORTED =
+  'The legacy v3/v4 format is no longer supported. Re-encode the file with a current version of stegdoc.';
+
 /**
  * Verify a v5/v6 file with the native engine, which also reads v6.
  */
@@ -73,133 +74,29 @@ function verifyNative(native, inputFile, options, spinner) {
  */
 async function verifyCommand(inputFile, options) {
   const spinner = ora('Verifying file...').start();
-  const issues = [];
 
   try {
-    const format = detectFormat(inputFile);
-    if (!format) {
-      throw new Error('Unknown file format. Supported formats: .xlsx, .docx');
-    }
-
-    // The native engine reads v5 and v6; the JS reader only knows v5.
     const native = loadNative();
-    if (native && native.probe(inputFile) === 'v5') {
-      return verifyNative(native, inputFile, options, spinner);
-    }
-
-    spinner.text = `Reading ${format.toUpperCase()} file...`;
-
-    let readResult;
-    if (format === 'xlsx') {
-      readResult = await readXlsxBase64(inputFile);
-    } else {
-      readResult = await readDocxBase64(inputFile);
+    if (!native) {
+      throw new Error(NATIVE_REQUIRED);
     }
 
-    const extracted = extractContent(readResult, format);
-    const metadata = extracted.metadata;
-    const encryptionMeta = extracted.encryptionMeta;
-
+    let probe;
     try {
-      validateMetadata(metadata);
-      spinner.succeed('Metadata valid');
-    } catch (e) {
-      issues.push(`Metadata: ${e.message}`);
-      spinner.warn('Metadata issues found');
+      probe = native.probe(inputFile);
+    } catch {
+      probe = 'unknown';
     }
-
-    const isEncrypted = metadata.encrypted || (encryptionMeta && encryptionMeta.length > 0);
-    const isV5 = isLogEmbedFormat(metadata);
-    const isV4 = !isV5 && isStreamingFormat(metadata);
-
-    // Check multi-part
-    const hasMultipleParts = isMultiPart(metadata) || metadata.partNumber !== null;
-    if (hasMultipleParts) {
-      spinner.text = 'Checking multi-part files...';
-      const inputDir = path.dirname(inputFile);
-      const allParts = findMultiPartFiles(inputDir, metadata.hash, format);
-      const totalParts = metadata.totalParts || allParts.length;
-
-      if (metadata.totalParts !== null && allParts.length !== metadata.totalParts) {
-        const missing = [];
-        const foundParts = new Set(allParts.map(p => p.partNumber));
-        for (let i = 1; i <= metadata.totalParts; i++) {
-          if (!foundParts.has(i)) missing.push(i);
-        }
-        issues.push(`Missing parts: ${missing.join(', ')}`);
-        spinner.warn(`Found ${allParts.length}/${metadata.totalParts} parts`);
-      } else {
-        spinner.succeed(`All ${totalParts} parts found`);
-      }
-    }
-
-    // Check password for encrypted files
-    if (isEncrypted) {
-      if (!options.password) {
-        issues.push('File is encrypted but no password provided');
-        spinner.warn('Encryption check skipped (no password)');
-      } else {
-        spinner.text = 'Verifying decryption...';
-        try {
-          if (isV5) {
-            await verifyV5Encryption(extracted, options.password);
-          } else if (isV4) {
-            await verifyV4Encryption(inputFile, format, encryptionMeta, options.password);
-          } else {
-            await verifyV3Encryption(inputFile, format, metadata, extracted.encryptedContent, encryptionMeta, options.password);
-          }
-          spinner.succeed('Decryption password valid');
-        } catch (e) {
-          issues.push('Decryption failed - wrong password or corrupted data');
-          spinner.fail('Decryption check failed');
-        }
-      }
+    if (probe === 'legacy') {
+      throw new Error(LEGACY_UNSUPPORTED);
     }
-
-    // Summary
-    console.log();
-
-    if (issues.length === 0) {
-      console.log(chalk.green.bold('✓ File verification passed!'));
-      console.log(chalk.cyan(`  Original file: ${metadata.originalFilename}`));
-      console.log(chalk.cyan(`  Size: ${formatBytes(metadata.originalSize)}`));
-      console.log(chalk.cyan(`  Encrypted: ${isEncrypted ? 'Yes' : 'No'}`));
-      console.log(chalk.cyan(`  Compressed: ${metadata.compressed ? 'Yes' : 'No'}`));
-
-      let versionStr = 'v3 (legacy)';
-      if (isV5) versionStr = 'v5 (log-embed)';
-      else if (isV4) versionStr = 'v4 (streaming)';
-      console.log(chalk.cyan(`  Format version: ${versionStr}`));
-
-      if (hasMultipleParts) {
-        const totalParts = metadata.totalParts || 'unknown';
-        console.log(chalk.cyan(`  Parts: ${totalParts}`));
-      }
-
-      console.log();
-      console.log(chalk.green('File is ready to decode.'));
-    } else {
-      console.log(chalk.yellow.bold('⚠ Verification completed with issues:'));
-      console.log();
-      for (const issue of issues) {
-        console.log(chalk.yellow(`  • ${issue}`));
-      }
-      console.log();
-
-      const hasBlockingIssue = issues.some(i =>
-        i.includes('Missing parts') ||
-        i.includes('Decryption failed') ||
-        i.includes('Metadata')
+    if (probe !== 'v5' && probe !== 'archive') {
+      throw new Error(
+        'Unknown file format. Supported formats: .xlsx, .docx, or a zip of them'
       );
-
-      if (hasBlockingIssue) {
-        console.log(chalk.red('File cannot be decoded until issues are resolved.'));
-        process.exit(1);
-      } else {
-        console.log(chalk.yellow('File may still be decodable. Run decode to attempt.'));
-      }
     }
 
+    return verifyNative(native, inputFile, options, spinner);
   } catch (error) {
     spinner.fail('Verification failed');
     console.error(chalk.red(`Error: ${error.message}`));
@@ -207,67 +104,4 @@ async function verifyCommand(inputFile, options) {
   }
 }
 
-/**
- * Verify v5 log-embed encryption
- */
-async function verifyV5Encryption(extracted, password) {
-  const { payloadBuffer, encryptionMeta } = extracted;
-  const { iv, salt, authTag } = unpackEncryptionMeta(encryptionMeta);
-  const decipher = createDecryptStream(password, iv, salt, authTag);
-  decipher.update(payloadBuffer);
-  decipher.final();
-}
-
-/**
- * Verify v4 per-part encryption
- */
-async function verifyV4Encryption(inputFile, format, encryptionMeta, password) {
-  const { iv, salt, authTag } = unpackEncryptionMeta(encryptionMeta);
-
-  let readResult;
-  if (format === 'xlsx') {
-    readResult = await readXlsxBase64(inputFile);
-  } else {
-    readResult = await readDocxBase64(inputFile);
-  }
-
-  const { encryptedContent } = extractContent(readResult, format);
-  const binaryData = Buffer.from(encryptedContent, 'base64');
-
-  const decipher = createDecryptStream(password, iv, salt, authTag);
-  decipher.update(binaryData);
-  decipher.final();
-}
-
-/**
- * Verify v3 shared encryption
- */
-async function verifyV3Encryption(inputFile, format, metadata, encryptedContent, encryptionMeta, password) {
-  const { iv, salt, authTag } = unpackEncryptionMeta(encryptionMeta);
-
-  let fullContent = encryptedContent;
-
-  if (isMultiPart(metadata)) {
-    const inputDir = path.dirname(inputFile);
-    const allParts = findMultiPartFiles(inputDir, metadata.hash, format);
-
-    if (allParts.length === metadata.totalParts) {
-      const contentParts = [];
-      for (const part of allParts) {
-        let partResult;
-        if (format === 'xlsx') {
-          partResult = await readXlsxBase64(part.path);
-        } else {
-          partResult = await readDocxBase64(part.path);
-        }
-        const { encryptedContent: partContent } = extractContent(partResult, format);
-        contentParts.push(partContent);
-      }
-      fullContent = contentParts.join('');
-    }
-  }
-
-  decrypt(fullContent, password, iv, salt, authTag);
-}
-
 module.exports = verifyCommand;