stegdoc 1.0.0

package/src/lib/docx-handler.js

@@ -0,0 +1,161 @@
+const { Document, Paragraph, TextRun, Packer } = require('docx');
+const fs = require('fs');
+const path = require('path');
+const { serializeMetadata, parseMetadata } = require('./metadata');
+const { parseXmlFromZip, ensureArray, extractTextContent } = require('./xml-utils');
+
+/**
+ * Create a DOCX file with base64 content and metadata
+ * @param {object} options - Options for creating the DOCX
+ * @param {string} options.base64Content - Base64 content to store
+ * @param {object} options.metadata - Metadata object
+ * @param {string} options.outputPath - Output file path
+ * @returns {Promise<string>} Path to created file
+ */
+async function createDocxWithBase64(options) {
+  const { base64Content, metadata, outputPath } = options;
+
+  // Serialize metadata to JSON string
+  const metadataStr = serializeMetadata(metadata);
+
+  // Create document with metadata in custom properties and hidden paragraph
+  const doc = new Document({
+    sections: [
+      {
+        properties: {},
+        children: [
+          // Metadata paragraph (hidden for user, but readable programmatically)
+          new Paragraph({
+            children: [
+              new TextRun({
+                text: `WHITENER_METADATA:${metadataStr}`,
+                size: 1, // Very small font
+              }),
+            ],
+          }),
+          // Separator
+          new Paragraph({
+            children: [
+              new TextRun({
+                text: '---',
+                break: 1,
+              }),
+            ],
+          }),
+          // Base64 content
+          new Paragraph({
+            children: [
+              new TextRun({
+                text: base64Content,
+                font: 'Courier New', // Monospace for base64
+                size: 16, // 8pt font
+              }),
+            ],
+          }),
+        ],
+      },
+    ],
+  });
+
+  // Generate DOCX file
+  const buffer = await Packer.toBuffer(doc);
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Write to file
+  fs.writeFileSync(outputPath, buffer);
+
+  return outputPath;
+}
+
+/**
+ * Read a DOCX file and extract base64 content and metadata
+ * Uses namespace-agnostic XML parsing to handle w:, ns0:, ns1:, etc.
+ * @param {string} docxPath - Path to DOCX file
+ * @returns {Promise<object>} Object containing base64Content and metadata
+ */
+async function readDocxBase64(docxPath) {
+  if (!fs.existsSync(docxPath)) {
+    throw new Error(`DOCX file not found: ${docxPath}`);
+  }
+
+  try {
+    // Parse document.xml with namespace-agnostic parser
+    const docParsed = parseXmlFromZip(docxPath, 'word/document.xml');
+
+    if (!docParsed) {
+      throw new Error('Could not find document.xml in DOCX file');
+    }
+
+    // Extract all text from the document
+    // Structure: document > body > p[] > r[] > t
+    const fullText = extractAllText(docParsed);
+
+    // Parse the extracted text
+    const metadataMarker = 'WHITENER_METADATA:';
+    const metadataStart = fullText.indexOf(metadataMarker);
+
+    if (metadataStart === -1) {
+      throw new Error('No metadata found in DOCX file. This may not be a whitener-encoded file.');
+    }
+
+    // Find the separator "---" which comes after the metadata
+    const separatorIndex = fullText.indexOf('---', metadataStart);
+
+    if (separatorIndex === -1) {
+      throw new Error('Invalid file format: separator not found');
+    }
+
+    // Extract metadata JSON between marker and separator
+    const metadataStr = fullText.substring(metadataStart + metadataMarker.length, separatorIndex).trim();
+    const metadata = parseMetadata(metadataStr);
+
+    // Extract base64 content (everything after the separator)
+    const base64Content = fullText.substring(separatorIndex + 3).trim();
+
+    return {
+      base64Content,
+      metadata,
+    };
+  } catch (error) {
+    throw new Error(`Failed to read DOCX file: ${error.message}`);
+  }
+}
+
+/**
+ * Extract all text content from parsed DOCX document
+ * @param {object} docParsed - Parsed document.xml
+ * @returns {string} Concatenated text content
+ */
+function extractAllText(docParsed) {
+  let fullText = '';
+
+  // Navigate: document > body > p (paragraphs)
+  const body = docParsed?.document?.body;
+  if (!body) return fullText;
+
+  const paragraphs = ensureArray(body.p);
+
+  for (const para of paragraphs) {
+    // Each paragraph has r (runs) containing t (text)
+    const runs = ensureArray(para.r);
+
+    for (const run of runs) {
+      // Text can be in 't' property
+      if (run.t !== undefined) {
+        fullText += extractTextContent(run.t);
+      }
+    }
+  }
+
+  return fullText;
+}
+
+module.exports = {
+  createDocxWithBase64,
+  readDocxBase64,
+};

package/src/lib/file-handler.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read a file and encode it to base64
+ * @param {string} filePath - Path to the file
+ * @returns {object} Object containing base64 string, filename, extension, and size
+ */
+function encodeFileToBase64(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+
+  const stats = fs.statSync(filePath);
+
+  if (!stats.isFile()) {
+    throw new Error(`Path is not a file: ${filePath}`);
+  }
+
+  const fileBuffer = fs.readFileSync(filePath);
+  const base64 = fileBuffer.toString('base64');
+  const filename = path.basename(filePath);
+  const extension = path.extname(filePath);
+
+  return {
+    base64,
+    filename,
+    extension,
+    size: stats.size,
+  };
+}
+
+/**
+ * Decode base64 string and write to file
+ * @param {string} base64 - Base64 encoded string
+ * @param {string} outputPath - Output file path
+ */
+function decodeBase64ToFile(base64, outputPath) {
+  const buffer = Buffer.from(base64, 'base64');
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, buffer);
+}
+
+/**
+ * Split base64 string into chunks based on size limit
+ * @param {string} base64 - Base64 string to split
+ * @param {number} chunkSizeBytes - Maximum size per chunk in bytes
+ * @returns {Array<string>} Array of base64 chunks
+ */
+function splitBase64(base64, chunkSizeBytes) {
+  const chunks = [];
+  let offset = 0;
+
+  while (offset < base64.length) {
+    chunks.push(base64.slice(offset, offset + chunkSizeBytes));
+    offset += chunkSizeBytes;
+  }
+
+  return chunks;
+}
+
+/**
+ * Merge base64 chunks back into a single string
+ * @param {Array<string>} chunks - Array of base64 chunks
+ * @returns {string} Merged base64 string
+ */
+function mergeBase64Chunks(chunks) {
+  return chunks.join('');
+}
+
+/**
+ * Calculate how many chunks will be needed for a file
+ * @param {number} fileSize - File size in bytes
+ * @param {number} chunkSizeBytes - Chunk size in bytes
+ * @returns {number} Number of chunks needed
+ */
+function calculateChunkCount(fileSize, chunkSizeBytes) {
+  // Base64 encoding increases size by ~33%
+  const base64Size = Math.ceil(fileSize * 4 / 3);
+  return Math.ceil(base64Size / chunkSizeBytes);
+}
+
+/**
+ * Validate if a path is writable
+ * @param {string} dirPath - Directory path to check
+ * @returns {boolean} True if writable
+ */
+function isDirectoryWritable(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.accessSync(dirPath, fs.constants.W_OK);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  encodeFileToBase64,
+  decodeBase64ToFile,
+  splitBase64,
+  mergeBase64Chunks,
+  calculateChunkCount,
+  isDirectoryWritable,
+};

package/src/lib/file-utils.js

@@ -0,0 +1,150 @@
+const fs = require('fs');
+const path = require('path');
+const { parseMetadata } = require('./metadata');
+const { parseFilename } = require('./utils');
+
+/**
+ * Extract content and metadata based on format
+ * @param {object} readResult - Result from readFile
+ * @param {string} format - File format ('xlsx' or 'docx')
+ * @returns {object} { encryptedContent, encryptionMeta, metadata }
+ */
+function extractContent(readResult, format) {
+  if (format === 'xlsx') {
+    return {
+      encryptedContent: readResult.base64Content,
+      encryptionMeta: readResult.encryptionMeta,
+      metadata: parseMetadata(readResult.metadata),
+    };
+  } else {
+    // DOCX: encryption meta is embedded in content with ||| separator
+    const { base64Content, metadata } = readResult;
+
+    // Check if this is a v2+ encrypted file
+    if (base64Content.includes('|||')) {
+      const [encryptionMeta, encryptedContent] = base64Content.split('|||');
+      return {
+        encryptedContent,
+        encryptionMeta,
+        metadata,
+      };
+    }
+
+    // Legacy unencrypted DOCX
+    return {
+      encryptedContent: base64Content,
+      encryptionMeta: null,
+      metadata,
+    };
+  }
+}
+
+/**
+ * Find all parts of a multi-part file in a directory
+ * @param {string} dirPath - Directory to search
+ * @param {string} hash - Original hash from metadata
+ * @param {string} format - File format ('xlsx' or 'docx')
+ * @param {number} [expectedParts] - Expected total parts (optional, for validation)
+ * @returns {Array<{path: string, partNumber: number, filename: string}>} Array of parts sorted by part number
+ */
+function findMultiPartFiles(dirPath, hash, format, expectedParts = null) {
+  const files = fs.readdirSync(dirPath);
+  const parts = [];
+  const ext = format === 'docx' ? '.docx' : '.xlsx';
+
+  // Also support legacy hex filenames for backward compatibility
+  const legacyBaseHash = hash.length >= 16 ? hash.slice(0, 16) : hash;
+
+  for (const file of files) {
+    if (!file.toLowerCase().endsWith(ext)) continue;
+
+    const parsed = parseFilename(file);
+    if (!parsed || parsed.partNumber === null) continue;
+
+    // Match by new realistic filename pattern
+    // Check if file matches the expected pattern (same reportId from hash)
+    if (parsed.reportId) {
+      // New realistic format - match by reportId (last 4 chars of hash)
+      // This is deterministic and doesn't depend on current date
+      const expectedReportId = hash.slice(-4).toUpperCase();
+      if (parsed.reportId === expectedReportId) {
+        parts.push({
+          path: path.join(dirPath, file),
+          partNumber: parsed.partNumber,
+          filename: file,
+          dateStr: parsed.dateStr,
+          timeStr: parsed.timeStr,
+        });
+      }
+    } else if (parsed.baseHash === legacyBaseHash) {
+      // Legacy hex format - match by base hash
+      parts.push({
+        path: path.join(dirPath, file),
+        partNumber: parsed.partNumber,
+        filename: file,
+      });
+    }
+  }
+
+  // Sort by part number
+  parts.sort((a, b) => a.partNumber - b.partNumber);
+
+  // For realistic filenames, ensure all parts have the same date/time pattern
+  // This handles edge cases where multiple file sets might share the same reportId
+  if (parts.length > 0 && parts[0].dateStr) {
+    const refDateStr = parts[0].dateStr;
+    const refTimeStr = parts[0].timeStr;
+    const filteredParts = parts.filter(
+      (p) => p.dateStr === refDateStr && p.timeStr === refTimeStr
+    );
+    // If filtering removed some parts, use the filtered set
+    if (filteredParts.length !== parts.length) {
+      parts.length = 0;
+      parts.push(...filteredParts);
+    }
+  }
+
+  // Validate sequential parts if expectedParts is provided
+  if (expectedParts !== null && parts.length === expectedParts) {
+    for (let i = 0; i < expectedParts; i++) {
+      if (parts[i].partNumber !== i + 1) {
+        throw new Error(`Missing part ${i + 1}. Parts must be sequential.`);
+      }
+    }
+  }
+
+  return parts;
+}
+
+/**
+ * Check if a directory is writable
+ * @param {string} dirPath - Directory path to check
+ * @returns {boolean} True if writable
+ */
+function isDirectoryWritable(dirPath) {
+  try {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+    fs.accessSync(dirPath, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Merge base64 chunks back into a single string
+ * @param {Array<string>} chunks - Array of base64 chunks
+ * @returns {string} Merged base64 string
+ */
+function mergeBase64Chunks(chunks) {
+  return chunks.join('');
+}
+
+module.exports = {
+  extractContent,
+  findMultiPartFiles,
+  isDirectoryWritable,
+  mergeBase64Chunks,
+};

package/src/lib/interactive.js

@@ -0,0 +1,190 @@
+/**
+ * Interactive prompts for encode/decode commands
+ */
+
+/**
+ * Check if running in interactive mode (no relevant flags provided)
+ * @param {object} options - Command options
+ * @param {string} command - Command name ('encode' or 'decode')
+ * @returns {boolean}
+ */
+function shouldRunInteractive(options, command) {
+  // If --yes flag is set, never run interactive
+  if (options.yes) return false;
+
+  // If --quiet flag is set, never run interactive
+  if (options.quiet) return false;
+
+  if (command === 'encode') {
+    // Run interactive if no format or password specified
+    const hasFormat = options.format && options.format !== 'xlsx'; // xlsx is default
+    const hasPassword = !!options.password;
+    return !hasFormat && !hasPassword;
+  }
+
+  if (command === 'decode') {
+    // For decode, only prompt if encrypted file needs password
+    // This is handled separately in decode command
+    return false;
+  }
+
+  return false;
+}
+
+/**
+ * Prompt for encode options interactively
+ * @param {string} filename - Input filename for context
+ * @returns {Promise<object>} Selected options
+ */
+async function promptEncodeOptions(filename) {
+  // Dynamic import for ESM inquirer
+  const { default: inquirer } = await import('inquirer');
+
+  console.log();
+
+  // First get format and encryption choice
+  const basicAnswers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'format',
+      message: 'Select output format:',
+      choices: [
+        { name: 'XLSX (Excel) - recommended, better hiding spots', value: 'xlsx' },
+        { name: 'DOCX (Word) - fallback option', value: 'docx' },
+      ],
+      default: 'xlsx',
+    },
+    {
+      type: 'confirm',
+      name: 'useEncryption',
+      message: 'Encrypt the file with a password?',
+      default: true,
+    },
+  ]);
+
+  let password;
+
+  // If encryption is enabled, prompt for password with confirmation
+  if (basicAnswers.useEncryption) {
+    let passwordsMatch = false;
+
+    while (!passwordsMatch) {
+      const { password: pwd } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'password',
+          message: 'Enter encryption password:',
+          mask: '*',
+          validate: (input) => {
+            if (input.length < 8) {
+              return 'Password must be at least 8 characters';
+            }
+            return true;
+          },
+        },
+      ]);
+
+      const { passwordConfirm } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'passwordConfirm',
+          message: 'Confirm password:',
+          mask: '*',
+        },
+      ]);
+
+      if (pwd === passwordConfirm) {
+        password = pwd;
+        passwordsMatch = true;
+      } else {
+        console.log('Passwords do not match. Please try again.\n');
+      }
+    }
+  }
+
+  // Get chunk size
+  const { chunkSize } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'chunkSize',
+      message: 'Chunk size or number of parts (e.g., 5MB, "3 parts", or "max"):',
+      default: '5MB',
+      validate: (input) => {
+        const trimmed = input.trim().toLowerCase();
+        // Allow special values for no splitting
+        if (['0', 'max', 'single', 'none'].includes(trimmed)) {
+          return true;
+        }
+        // Allow "X parts" format
+        if (/^\d+\s*parts?$/i.test(trimmed)) {
+          const num = parseInt(trimmed, 10);
+          if (num < 1) return 'Number of parts must be at least 1';
+          return true;
+        }
+        // Allow size format
+        if (!/^\d+(\.\d+)?\s*(B|KB|MB|GB)?$/i.test(trimmed)) {
+          return 'Use "5MB", "3 parts", or "max" for no splitting';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return {
+    format: basicAnswers.format,
+    password,
+    chunkSize,
+  };
+}
+
+/**
+ * Prompt for password when decoding encrypted file
+ * @returns {Promise<string>} Password
+ */
+async function promptPassword() {
+  const { default: inquirer } = await import('inquirer');
+
+  const { password } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Enter decryption password:',
+      mask: '*',
+      validate: (input) => {
+        if (!input) {
+          return 'Password is required for encrypted files';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return password;
+}
+
+/**
+ * Prompt for confirmation before overwriting
+ * @param {string} filePath - Path to file that will be overwritten
+ * @returns {Promise<boolean>} True if user confirms
+ */
+async function promptOverwrite(filePath) {
+  const { default: inquirer } = await import('inquirer');
+
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `File "${filePath}" already exists. Overwrite?`,
+      default: false,
+    },
+  ]);
+
+  return confirm;
+}
+
+module.exports = {
+  shouldRunInteractive,
+  promptEncodeOptions,
+  promptPassword,
+  promptOverwrite,
+};