stegdoc 5.6.0 → 6.0.0

package/src/commands/decode.js

@@ -4,14 +4,19 @@ const { finished } = require('stream/promises');
 const chalk = require('chalk');
 const ora = require('ora');
 const { readDocxBase64, } = require('../lib/docx-handler');
-const { readXlsxBase64, readXlsxV5 } = require('../lib/xlsx-handler');
-const { validateMetadata, isMultiPart, isStreamingFormat, isLogEmbedFormat, parseMetadata } = require('../lib/metadata');
-const { detectFormat, formatBytes, generateContentHash } = require('../lib/utils');
+const { readXlsxBase64 } = require('../lib/xlsx-handler');
+const { validateMetadata, isMultiPart, isStreamingFormat } = require('../lib/metadata');
+const { detectFormat, formatBytes, generateContentHash, safeFilename } = require('../lib/utils');
 const { decrypt, unpackEncryptionMeta, createDecryptStream } = require('../lib/crypto');
-const { decompress, createDecompressStream, decompressBrotli, createBrotliDecompressStream } = require('../lib/compression');
+const { decompress, createDecompressStream } = require('../lib/compression');
 const { promptPassword, promptOverwrite } = require('../lib/interactive');
 const { extractContent, findMultiPartFiles, mergeBase64Chunks } = require('../lib/file-utils');
 const { HashPassthrough } = require('../lib/streams');
+const { loadNative } = require('../lib/native');
+
+const NATIVE_REQUIRED =
+  'This is a v5 log-embed file. Decoding it requires the native engine, which is not installed. ' +
+  'Reinstall stegdoc, or build it with `pnpm build:native`.';
 
 /**
  * Read file based on format
@@ -33,8 +38,18 @@ async function decodeCommand(inputFile, options) {
 
   try {
     const format = detectFormat(inputFile);
+
+    // Prefer the native engine for v5/v6 files and transport archives. It
+    // returns false for anything the legacy JS paths must handle.
+    const native = loadNative();
+    if (native && (await decodeV5Native(native, inputFile, format, options, spinner, quiet))) {
+      return;
+    }
+
     if (!format) {
-      throw new Error('Unknown file format. Supported formats: .xlsx, .docx');
+      throw new Error(
+        'Unknown file format. Supported formats: .xlsx, .docx, or a zip of them'
+      );
     }
 
     spinner.text = `Reading ${format.toUpperCase()} file...`;
@@ -44,9 +59,14 @@ async function decodeCommand(inputFile, options) {
 
     // Route based on format version
     if (readResult.formatVersion === 'v5') {
-      await decodeV5(inputFile, format, readResult, options, spinner, quiet);
-    } else {
-      // Legacy v3/v4 path
+      // The CommonJS v5 decoder survives only for the legacy v3/v4 formats; its
+      // output path is not sanitised, so log-embed files must go through the
+      // native engine. Reaching here means the binding is missing.
+      throw new Error(NATIVE_REQUIRED);
+    }
+
+    // Legacy v3/v4 path
+    {
       const { encryptedContent, encryptionMeta, metadata } = extractContent(readResult, format);
       validateMetadata(metadata);
 
@@ -96,190 +116,118 @@ async function decodeCommand(inputFile, options) {
 }
 
 /**
- * Resolve output path from options and metadata
+ * Resolve output path from options and metadata.
+ *
+ * `metadata.originalFilename` is unauthenticated, so it is reduced to a bare
+ * name before it is joined onto any directory (FORMAT.md 11.1).
  */
 function resolveOutputPath(options, metadata) {
+  const name = safeFilename(metadata.originalFilename);
   if (options.output) {
     if (fs.existsSync(options.output) && fs.statSync(options.output).isDirectory()) {
-      return path.join(options.output, metadata.originalFilename);
+      return path.join(options.output, name);
     } else if (!path.extname(options.output) && !fs.existsSync(options.output)) {
       fs.mkdirSync(options.output, { recursive: true });
-      return path.join(options.output, metadata.originalFilename);
+      return path.join(options.output, name);
     } else {
       return options.output;
     }
   }
-  return path.join(process.cwd(), metadata.originalFilename);
+  return path.join(process.cwd(), name);
 }
 
-// ─── v5 Log-Embed Decode ────────────────────────────────────────────────────
-
 /**
- * Decode a v5 log-embed XLSX file
+ * Resolve the output path using a filename the native engine already
+ * sanitised. `safeFilename` is a bare name, so joining it cannot escape.
  */
-async function decodeV5(inputFile, format, firstReadResult, options, spinner, quiet) {
-  const metadata = firstReadResult.metadata;
-  validateMetadata(metadata);
-
-  const isEncrypted = metadata.encrypted || false;
-  const isCompressed = metadata.compressed || false;
-  const compressionAlgo = metadata.compressionAlgo || 'brotli';
-
-  spinner.succeed && spinner.succeed(`${format.toUpperCase()} file read (v5 log-embed format)`);
+function resolveNativeOutputPath(options, safeFilename) {
+  if (options.output) {
+    if (fs.existsSync(options.output) && fs.statSync(options.output).isDirectory()) {
+      return path.join(options.output, safeFilename);
+    } else if (!path.extname(options.output) && !fs.existsSync(options.output)) {
+      fs.mkdirSync(options.output, { recursive: true });
+      return path.join(options.output, safeFilename);
+    } else {
+      return options.output;
+    }
+  }
+  return path.join(process.cwd(), safeFilename);
+}
 
-  if (!quiet) {
-    console.log(chalk.cyan(`  Original file: ${metadata.originalFilename}`));
-    console.log(chalk.cyan(`  Original size: ${formatBytes(metadata.originalSize)}`));
-    console.log(chalk.cyan(`  Encrypted: ${isEncrypted ? 'Yes' : 'No'}`));
-    console.log(chalk.cyan(`  Compressed: ${isCompressed ? `Yes (${compressionAlgo})` : 'No'}`));
+/**
+ * Decode a v5 file through the native engine.
+ *
+ * Returns true when the file was handled, false when it is not a v5 file the
+ * native engine understands and the caller should fall back to the JS paths.
+ */
+async function decodeV5Native(native, inputFile, format, options, spinner, quiet) {
+  let version;
+  try {
+    version = native.probe(inputFile);
+  } catch {
+    // Not a readable container; let the JS paths produce the error.
+    return false;
   }
+  if (version !== 'v5' && version !== 'archive') return false;
+
+  const label = format ? format.toUpperCase() : 'ZIP';
+  spinner.text = `Reading ${label} file...`;
 
-  if (isEncrypted && !options.password) {
+  let result;
+  try {
+    result = native.decode(inputFile, options.password || undefined, undefined);
+  } catch (error) {
+    if (!String(error.message).startsWith('STEGDOC_PASSWORD_REQUIRED')) {
+      throw error;
+    }
     if (quiet || options.yes) {
       throw new Error('Password is required for encrypted files. Use -p or --password to specify.');
     }
     options.password = await promptPassword();
+    result = native.decode(inputFile, options.password || undefined, undefined);
   }
 
-  let outputPath = resolveOutputPath(options, metadata);
+  const engineVersion = result.formatVersion || 'v5';
+  spinner.succeed && spinner.succeed(`${label} file read (${engineVersion} log-embed format)`);
 
-  if (fs.existsSync(outputPath) && !options.force) {
-    if (quiet || options.yes) {
-      throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
-    }
-    const shouldOverwrite = await promptOverwrite(outputPath);
-    if (!shouldOverwrite) {
-      console.log(chalk.yellow('Operation cancelled.'));
-      process.exit(0);
-    }
+  if (!quiet) {
+    console.log(chalk.cyan(`  Original file: ${result.originalFilename}`));
+    console.log(chalk.cyan(`  Original size: ${formatBytes(result.originalSize)}`));
+    console.log(chalk.cyan(`  Encrypted: ${result.encrypted ? 'Yes' : 'No'}`));
+    console.log(chalk.cyan(`  Compressed: ${result.compressed ? 'Yes (brotli)' : 'No'}`));
   }
 
-  // Ensure output directory exists
+  const outputPath = resolveNativeOutputPath(options, result.safeFilename);
   const outputDir = path.dirname(outputPath);
   if (!fs.existsSync(outputDir)) {
     fs.mkdirSync(outputDir, { recursive: true });
   }
 
-  // Set up output pipeline: [decompress] → hash → file
-  const hashStream = new HashPassthrough();
-  const outputStream = fs.createWriteStream(outputPath);
-
-  let decompressStream = null;
-  if (isCompressed) {
-    if (compressionAlgo === 'brotli') {
-      decompressStream = createBrotliDecompressStream();
-    } else {
-      decompressStream = createDecompressStream();
-    }
-    decompressStream.pipe(hashStream).pipe(outputStream);
-  } else {
-    hashStream.pipe(outputStream);
-  }
-
-  const writeTarget = isCompressed ? decompressStream : hashStream;
-
-  // Check for multi-part
-  const hasMultipleParts = isMultiPart(metadata) || metadata.partNumber !== null;
-  let totalPartsFound = 1;
-
-  if (hasMultipleParts) {
-    const inputDir = path.dirname(inputFile);
-    const allParts = findMultiPartFiles(inputDir, metadata.hash, format);
-    totalPartsFound = allParts.length;
-
-    if (metadata.totalParts !== null && totalPartsFound !== metadata.totalParts) {
-      throw new Error(
-        `Missing parts! Found ${totalPartsFound} of ${metadata.totalParts} parts. ` +
-        `Make sure all parts are in the same directory.`
-      );
-    }
-
-    spinner.text = `Multi-part file detected (${totalPartsFound} parts)`;
-    spinner.succeed && spinner.succeed(`Found all ${totalPartsFound} parts`);
-
-    for (let i = 0; i < allParts.length; i++) {
-      const pct = Math.round(((i + 1) / totalPartsFound) * 100);
-      const partSpinner = quiet ? spinner : ora(`Decoding part ${i + 1}/${totalPartsFound} (${pct}%)...`).start();
-
-      const partResult = await readFile(allParts[i].path, format);
-
-      let partPayload;
-      let partEncMeta;
-
-      if (partResult.formatVersion === 'v5') {
-        partPayload = partResult.payloadBuffer;
-        partEncMeta = partResult.encryptionMeta;
-      } else {
-        // Shouldn't happen for v5, but handle gracefully
-        const extracted = extractContent(partResult, format);
-        partPayload = Buffer.from(extracted.encryptedContent, 'base64');
-        partEncMeta = extracted.encryptionMeta;
-      }
-
-      if (isEncrypted) {
-        const { iv, salt, authTag } = unpackEncryptionMeta(partEncMeta);
-        const decipher = createDecryptStream(options.password, iv, salt, authTag);
-        try {
-          const decrypted = Buffer.concat([decipher.update(partPayload), decipher.final()]);
-          writeTarget.write(decrypted);
-        } catch (error) {
-          throw new Error('Decryption failed: Invalid password or corrupted data');
-        }
-      } else {
-        writeTarget.write(partPayload);
-      }
-
-      partSpinner.succeed && partSpinner.succeed(`Part ${i + 1}/${totalPartsFound} decoded`);
-    }
-  } else {
-    // Single file
-    spinner.text = 'Decoding...';
-
-    const payloadBuffer = firstReadResult.payloadBuffer;
-    const encryptionMeta = firstReadResult.encryptionMeta;
-
-    if (isEncrypted) {
-      const { iv, salt, authTag } = unpackEncryptionMeta(encryptionMeta);
-      const decipher = createDecryptStream(options.password, iv, salt, authTag);
-      try {
-        const decrypted = Buffer.concat([decipher.update(payloadBuffer), decipher.final()]);
-        writeTarget.write(decrypted);
-      } catch (error) {
-        throw new Error('Decryption failed: Invalid password or corrupted data');
-      }
-    } else {
-      writeTarget.write(payloadBuffer);
+  if (fs.existsSync(outputPath) && !options.force) {
+    if (quiet || options.yes) {
+      throw new Error(`File already exists: ${outputPath}. Use --force to overwrite.`);
     }
-  }
-
-  // End pipeline and wait
-  writeTarget.end();
-  await finished(outputStream);
-
-  // Verify integrity
-  if (metadata.contentHash) {
-    spinner.text = 'Verifying integrity...';
-    const actualHash = hashStream.digest;
-    if (actualHash !== metadata.contentHash) {
-      try { fs.unlinkSync(outputPath); } catch { /* ignore */ }
-      throw new Error('Integrity check failed! The file may be corrupted or tampered with.');
+    const shouldOverwrite = await promptOverwrite(outputPath);
+    if (!shouldOverwrite) {
+      console.log(chalk.yellow('Operation cancelled.'));
+      process.exit(0);
     }
-    spinner.succeed && spinner.succeed('Integrity verified (SHA-256 match)');
   }
 
+  fs.writeFileSync(outputPath, result.bytes);
   spinner.succeed && spinner.succeed('Decoding complete!');
 
   if (!quiet) {
-    const outputSize = fs.statSync(outputPath).size;
     console.log();
     console.log(chalk.green.bold('✓ File decoded successfully!'));
-    console.log(chalk.cyan(`  Original: ${metadata.originalFilename}`));
+    console.log(chalk.cyan(`  Original: ${result.originalFilename}`));
     console.log(chalk.cyan(`  Output: ${outputPath}`));
-    console.log(chalk.cyan(`  Size: ${formatBytes(outputSize)}`));
-    if (hasMultipleParts) {
-      console.log(chalk.cyan(`  Parts merged: ${totalPartsFound}`));
+    console.log(chalk.cyan(`  Size: ${formatBytes(result.bytes.length)}`));
+    if (result.partCount > 1) {
+      console.log(chalk.cyan(`  Parts merged: ${result.partCount}`));
     }
   }
+  return true;
 }
 
 // ─── v4 Streaming Decode ────────────────────────────────────────────────────