stegdoc 5.2.0 → 5.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stegdoc",
-  "version": "5.2.0",
+  "version": "5.4.0",
   "description": "Hide files inside Office documents (XLSX/DOCX) with AES-256 encryption and steganography",
   "main": "src/index.js",
   "bin": {

package/src/commands/decode.js

@@ -198,7 +198,8 @@ async function decodeV5(inputFile, format, firstReadResult, options, spinner, qu
     spinner.succeed && spinner.succeed(`Found all ${totalPartsFound} parts`);
 
     for (let i = 0; i < allParts.length; i++) {
-      const partSpinner = quiet ? spinner : ora(`Decoding part ${i + 1} of ${totalPartsFound}...`).start();
+      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);
 
@@ -228,7 +229,7 @@ async function decodeV5(inputFile, format, firstReadResult, options, spinner, qu
         writeTarget.write(partPayload);
       }
 
-      partSpinner.succeed && partSpinner.succeed(`Part ${i + 1} decoded`);
+      partSpinner.succeed && partSpinner.succeed(`Part ${i + 1}/${totalPartsFound} decoded`);
     }
   } else {
     // Single file

package/src/commands/encode.js

@@ -178,16 +178,52 @@ async function encodeCommand(inputFile, options) {
     // Generate session salt for encryption
     const sessionSalt = useEncryption ? generateSalt() : null;
 
-    spinner.text = useCompression ? 'Compressing (Brotli) and encoding...' : 'Encoding...';
+    // === Phase 1: Compress and collect all chunks ===
+    spinner.text = useCompression ? 'Compressing...' : 'Reading...';
 
     const partFiles = [];
-
-    // v5 pipeline: compress (brotli) → collect binary chunks → encrypt per-part → embed in log lines
     const binaryChunkSize = chunkSizeBytes === Infinity ? Infinity : Math.floor(chunkSizeBytes * 3 / 4);
 
-    const onBinaryChunkReady = async (binaryBuffer, index) => {
+    // Collect all chunks first (enables parallel part creation + known total)
+    const collectedChunks = [];
+    const collectChunk = async (binaryBuffer, index) => {
+      collectedChunks.push({ buffer: Buffer.from(binaryBuffer), index });
+    };
+
+    const collector = new BinaryChunkCollector(binaryChunkSize, collectChunk);
+
+    const streams = [fs.createReadStream(streamSource)];
+
+    // Add progress tracking (tracks input bytes read)
+    if (!quiet) {
+      const progressStream = new ProgressTransform(fileSize, (processed, total) => {
+        const pct = Math.min(100, Math.round((processed / total) * 100));
+        const processedFmt = formatBytes(processed);
+        const totalFmt = formatBytes(total);
+        const phase = useCompression ? 'Compressing' : 'Reading';
+        spinner.text = `${phase}... ${processedFmt} / ${totalFmt} (${pct}%)`;
+      });
+      streams.push(progressStream);
+    }
+
+    if (useCompression) {
+      streams.push(createBrotliCompressStream());
+    }
+    streams.push(collector);
+
+    await pipeline(...streams);
+
+    const totalParts = collectedChunks.length;
+    spinner.succeed && spinner.succeed(`${useCompression ? 'Compressed' : 'Read'}: ${totalParts} part${totalParts !== 1 ? 's' : ''} to create`);
+
+    // === Phase 2: Create parts in parallel ===
+    const os = require('os');
+    const concurrency = Math.min(totalParts, Math.max(1, os.cpus().length));
+    let completedParts = 0;
+    const partSpinner = quiet ? spinner : ora(`Creating parts... 0/${totalParts}`).start();
+
+    const createPart = async ({ buffer: binaryBuffer, index }) => {
       const partNumber = index + 1;
-      const partSpinner = quiet ? spinner : ora(`Creating part ${partNumber}...`).start();
 
       let payloadBuffer;
       let encryptionMeta = '';
@@ -208,7 +244,7 @@ async function encodeCommand(inputFile, options) {
         originalExtension: extension,
         hash,
         partNumber,
-        totalParts: null,
+        totalParts,
         originalSize: fileSize,
         format,
         encrypted: useEncryption,
@@ -262,35 +298,26 @@ async function encodeCommand(inputFile, options) {
 
       partFiles.push(outputPath);
       createdFiles.push(outputPath);
-      partSpinner.succeed && partSpinner.succeed(`Created: ${outputFilename} (${formatBytes(payloadBuffer.length)} payload, ${dataLineCount} data lines)`);
-    };
-
-    const collector = new BinaryChunkCollector(binaryChunkSize, onBinaryChunkReady);
 
-    const streams = [fs.createReadStream(streamSource)];
+      completedParts++;
+      const pct = Math.round((completedParts / totalParts) * 100);
+      partSpinner.text = `Creating parts... ${completedParts}/${totalParts} (${pct}%)`;
+    };
 
-    // Add progress tracking before compression (tracks input bytes read)
-    if (!quiet) {
-      const progressStream = new ProgressTransform(fileSize, (processed, total) => {
-        const pct = Math.min(100, Math.round((processed / total) * 100));
-        const processedFmt = formatBytes(processed);
-        const totalFmt = formatBytes(total);
-        const phase = useCompression ? 'Compressing' : 'Processing';
-        spinner.text = `${phase}... ${processedFmt} / ${totalFmt} (${pct}%)`;
-      });
-      streams.push(progressStream);
-    }
+    // Run part creation in parallel with limited concurrency
+    const chunks = [...collectedChunks];
+    const executing = new Set();
 
-    if (useCompression) {
-      streams.push(createBrotliCompressStream());
+    for (const chunk of chunks) {
+      const promise = createPart(chunk).then(() => executing.delete(promise));
+      executing.add(promise);
+      if (executing.size >= concurrency) {
+        await Promise.race(executing);
+      }
     }
-    streams.push(collector);
-
-    await pipeline(...streams);
-
-    const totalParts = partFiles.length;
+    await Promise.all(executing);
 
-    spinner.succeed && spinner.succeed('Encoding complete!');
+    partSpinner.succeed && partSpinner.succeed(`Created ${totalParts} part${totalParts !== 1 ? 's' : ''}`);
 
     if (!quiet) {
       console.log();

package/src/index.js

@@ -11,7 +11,7 @@ const verifyCommand = require('./commands/verify');
 program
   .name('stegdoc')
   .description('CLI tool to encode files into Office documents with AES-256 encryption')
-  .version('5.2.0');
+  .version('5.4.0');
 
 // Encode command
 program

package/src/lib/xlsx-handler.js

@@ -117,6 +117,7 @@ async function createXlsxPartV5(options) {
 
 /**
  * Read a v5 log-embed XLSX file and extract payload.
+ * Uses fast regex-based XML scanning instead of full DOM parsing for speed.
  * @param {string} xlsxPath - Path to XLSX file
  * @returns {object} { payloadBuffer, metadataJson, encryptionMeta, metadata }
  */
@@ -125,62 +126,67 @@ async function readXlsxV5(xlsxPath) {
     throw new Error(`XLSX file not found: ${xlsxPath}`);
   }
 
-  // Parse shared strings
-  let sharedStrings = [];
-  const ssParsed = parseXmlFromZip(xlsxPath, 'xl/sharedStrings.xml');
-  if (ssParsed && ssParsed.sst && ssParsed.sst.si) {
-    const siArray = ensureArray(ssParsed.sst.si);
-    sharedStrings = siArray.map((si) => extractTextContent(si.t));
+  // Read file once and reuse the zip instance
+  const fileBuffer = fs.readFileSync(xlsxPath);
+  const zip = new AdmZip(fileBuffer);
+
+  // Parse shared strings (only if present — v5 files created with useSharedStrings:false may not have them)
+  let sharedStrings = null;
+  const ssEntry = zip.getEntry('xl/sharedStrings.xml');
+  if (ssEntry) {
+    sharedStrings = [];
+    const ssXml = ssEntry.getData().toString('utf8');
+    // Fast extract: match each <si><t>...</t></si> or <si><t ...>...</t></si>
+    const siRegex = /<si><t[^>]*>([^<]*)<\/t><\/si>/g;
+    let match;
+    while ((match = siRegex.exec(ssXml)) !== null) {
+      sharedStrings.push(match[1]);
+    }
   }
 
-  // Parse sheet1 (the only sheet in v5)
-  const sheetParsed = parseXmlFromZip(xlsxPath, 'xl/worksheets/sheet1.xml');
-  if (!sheetParsed) {
+  // Extract sheet1.xml raw string
+  const sheetEntry = zip.getEntry('xl/worksheets/sheet1.xml');
+  if (!sheetEntry) {
     throw new Error('Sheet not found in XLSX file.');
   }
+  const sheetXml = sheetEntry.getData().toString('utf8');
 
-  // Extract all rows as arrays of cell values
+  // Fast row extraction using regex — much faster than full DOM parsing
   const allRows = [];
-  const sheetData = sheetParsed.worksheet?.sheetData;
-
-  if (sheetData && sheetData.row) {
-    const rows = ensureArray(sheetData.row);
-
-    for (const row of rows) {
-      if (!row.c) continue;
-      const cells = ensureArray(row.c);
-
-      // Build a sparse array for this row
-      const rowValues = [];
-      for (const cell of cells) {
-        const cellRef = cell['@_r'];
-        if (!cellRef) continue;
-
-        // Parse column index from cell reference (e.g., "A2" -> col 0, "J2" -> col 9)
-        const colMatch = cellRef.match(/^([A-Z]+)/);
-        if (!colMatch) continue;
-        const colIdx = colLetterToIndex(colMatch[1]);
-
-        const cellType = cell['@_t'];
-        const cellValue = cell.v;
-
-        let value;
-        if (cellType === 's' && cellValue !== undefined) {
-          const ssIndex = parseInt(cellValue, 10);
-          value = ssIndex < sharedStrings.length ? sharedStrings[ssIndex] : '';
-        } else if (cellType === 'inlineStr' && cell.is) {
-          value = extractTextContent(cell.is.t);
-        } else if (cellValue !== undefined) {
-          value = String(cellValue);
-        } else {
-          value = '';
-        }
-
-        rowValues[colIdx] = value;
+  const rowRegex = /<row [^>]*>(.*?)<\/row>/gs;
+  const cellRegex = /<c r="([A-Z]+)\d+"(?: t="([^"]*)")?[^>]*>(?:<v>([^<]*)<\/v>|<is><t[^>]*>([^<]*)<\/t><\/is>)?<\/c>/g;
+
+  let rowMatch;
+  while ((rowMatch = rowRegex.exec(sheetXml)) !== null) {
+    const rowXml = rowMatch[1];
+    const rowValues = [];
+
+    let cellMatch;
+    cellRegex.lastIndex = 0;
+    while ((cellMatch = cellRegex.exec(rowXml)) !== null) {
+      const colLetter = cellMatch[1];
+      const cellType = cellMatch[2] || '';
+      const vValue = cellMatch[3];
+      const inlineValue = cellMatch[4];
+
+      const colIdx = colLetterToIndex(colLetter);
+
+      let value;
+      if (cellType === 's' && vValue !== undefined && sharedStrings) {
+        const ssIndex = parseInt(vValue, 10);
+        value = ssIndex < sharedStrings.length ? sharedStrings[ssIndex] : '';
+      } else if (inlineValue !== undefined) {
+        value = decodeXmlEntities(inlineValue);
+      } else if (vValue !== undefined) {
+        value = decodeXmlEntities(vValue);
+      } else {
+        value = '';
       }
 
-      allRows.push(rowValues);
+      rowValues[colIdx] = value;
     }
+
+    allRows.push(rowValues);
   }
 
   // Skip the first row (column headers)
@@ -194,6 +200,19 @@ async function readXlsxV5(xlsxPath) {
   return decodeLogLines(dataRows);
 }
 
+/**
+ * Decode XML entities in a string value
+ */
+function decodeXmlEntities(str) {
+  if (!str || !str.includes('&')) return str;
+  return str
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&apos;/g, "'")
+    .replace(/&quot;/g, '"');
+}
+
 /**
  * Convert column letter to 0-based index (A=0, B=1, ..., Z=25, AA=26)
  */