stegdoc 5.7.0 → 6.0.0

package/src/index.js

@@ -2,6 +2,7 @@
 
 const { program } = require('commander');
 const chalk = require('chalk');
+const { version } = require('../package.json');
 const encodeCommand = require('./commands/encode');
 const decodeCommand = require('./commands/decode');
 const infoCommand = require('./commands/info');
@@ -11,24 +12,27 @@ const verifyCommand = require('./commands/verify');
 program
   .name('stegdoc')
   .description('CLI tool to encode files into Office documents with AES-256 encryption')
-  .version('5.6.0');
+  .version(version);
 
 // Encode command
 program
-  .command('encode <file>')
-  .description('Encode a file into XLSX/DOCX format with compression and optional encryption')
+  .command('encode <inputs...>')
+  .description('Encode one or more files (or folders) into XLSX/DOCX format with compression and optional encryption')
   .option('-o, --output-dir <dir>', 'Output directory for files', process.cwd())
+  .option('--bundle-name <name>', 'Filename recorded for a multi-input bundle', 'bundle.zip')
   .option('-s, --chunk-size <size>', 'Maximum size per output file (e.g., "5MB", "25MB")', '5MB')
   .option('-f, --format <format>', 'Output format: xlsx (default) or docx', 'xlsx')
   .option('-p, --password <password>', 'Encryption password (optional, but recommended)')
   .option('--force', 'Overwrite existing files without asking')
   .option('--legacy', 'Use v4 format (hidden sheet + gzip) for backward compatibility')
+  .option('--v5', 'Emit the v5 format (PBKDF2) instead of the v6 default')
+  .option('--v6', 'Emit the v6 format (default; Argon2id, authenticated metadata)')
   .option('--no-limit', 'Bypass DOCX 1 MB size limit (large files will produce huge documents)')
   .option('-q, --quiet', 'Minimal output (for scripting)')
   .option('-y, --yes', 'Skip interactive prompts, use defaults')
-  .action(async (file, options) => {
+  .action(async (inputs, options) => {
     try {
-      await encodeCommand(file, options);
+      await encodeCommand(inputs, options);
     } catch (error) {
       console.error(chalk.red(`Error: ${error.message}`));
       process.exit(1);

package/src/lib/bindings.js

@@ -0,0 +1,99 @@
+'use strict';
+
+/**
+ * The napi binding target table, shared by the loader and the build scripts.
+ *
+ * The published package ships no binary. Each target becomes an optional
+ * dependency `@stegdoc/binding-<suffix>` carrying one `.node`, selected at
+ * require time by `src/lib/native.js`. The shape matches the ecosystem norm
+ * (`@swc/core-*`, `@rollup/rollup-*`), which is also what the airgap
+ * lockfile's `os`/`cpu`/`libc` filter expects.
+ *
+ * @typedef {object} BindingTarget
+ * @property {string} triple - Rust target triple.
+ * @property {string} suffix - npm name suffix, `<os>-<cpu>[-<libc>]`.
+ * @property {string} os - npm `os` field value.
+ * @property {string} cpu - npm `cpu` field value.
+ * @property {string} [libc] - npm `libc` field value.
+ * @property {string} lib - Artifact filename Cargo produces.
+ */
+
+/** Scope the platform packages publish under. Changing it is a one-line rename. */
+const SCOPE = '@stegdoc';
+
+/** @type {BindingTarget[]} */
+const TARGETS = [
+  {
+    triple: 'x86_64-pc-windows-msvc',
+    suffix: 'win32-x64-msvc',
+    os: 'win32',
+    cpu: 'x64',
+    lib: 'stegdoc_node.dll',
+  },
+  {
+    triple: 'x86_64-unknown-linux-gnu',
+    suffix: 'linux-x64-gnu',
+    os: 'linux',
+    cpu: 'x64',
+    libc: 'glibc',
+    lib: 'libstegdoc_node.so',
+  },
+  {
+    triple: 'aarch64-unknown-linux-gnu',
+    suffix: 'linux-arm64-gnu',
+    os: 'linux',
+    cpu: 'arm64',
+    libc: 'glibc',
+    lib: 'libstegdoc_node.so',
+  },
+  {
+    triple: 'x86_64-apple-darwin',
+    suffix: 'darwin-x64',
+    os: 'darwin',
+    cpu: 'x64',
+    lib: 'libstegdoc_node.dylib',
+  },
+  {
+    triple: 'aarch64-apple-darwin',
+    suffix: 'darwin-arm64',
+    os: 'darwin',
+    cpu: 'arm64',
+    lib: 'libstegdoc_node.dylib',
+  },
+];
+
+/**
+ * The npm package name for a target.
+ * @param {BindingTarget} target
+ * @returns {string}
+ */
+function packageName(target) {
+  return `${SCOPE}/binding-${target.suffix}`;
+}
+
+/**
+ * Whether the running Linux is musl-based. No musl package is published, so
+ * the loader must not pick the glibc binary for it.
+ * @returns {boolean}
+ */
+function isMusl() {
+  if (process.platform !== 'linux') return false;
+  try {
+    return !process.report.getReport().header.glibcVersionRuntime;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The target matching the running platform, or null when none is published.
+ * @returns {BindingTarget|null}
+ */
+function hostTarget() {
+  if (isMusl()) return null;
+  return (
+    TARGETS.find((target) => target.os === process.platform && target.cpu === process.arch) || null
+  );
+}
+
+module.exports = { SCOPE, TARGETS, packageName, hostTarget };

package/src/lib/log-generator.js

@@ -657,9 +657,12 @@ function decodeLogLines(allRows) {
   const headerStr = headerPayload.toString('utf8');
 
   // Parse header: "STGD05|<metaLen>|<encLen>|{metadataJson}{encryptionMeta}"
-  const markerIdx = headerStr.indexOf('STGD05|');
+  const markerIdx = headerStr.search(/STGD0[56]\|/);
   if (markerIdx === -1) {
-    throw new Error('Invalid v5 format: magic marker not found. This may not be a stegdoc v5 file.');
+    throw new Error('Invalid log-embed format: magic marker not found. This may not be a stegdoc file.');
+  }
+  if (headerStr.startsWith('STGD06|', markerIdx)) {
+    throw new Error('This file uses the v6 format, which the JavaScript decoder cannot read. The native engine is required.');
   }
 
   const afterMarker = headerStr.slice(markerIdx + 7);

package/src/lib/native.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const path = require('path');
+
+const { hostTarget, packageName } = require('./bindings');
+
+const NATIVE_DIR = path.join(__dirname, '..', '..', 'native');
+
+let binding;
+let resolved = false;
+
+/**
+ * Load the native format engine, or return null when it is not available.
+ *
+ * Resolution order:
+ *   1. `STEGDOC_NATIVE_PATH`, an explicit `.node` file.
+ *   2. The platform package (`@stegdoc/binding-<suffix>`) from the published
+ *      install's optionalDependencies.
+ *   3. `native/stegdoc.node`, the local `pnpm build:native` output.
+ *
+ * The binding is required for log-embed (v5/v6) decode and is the preferred
+ * encoder. The CommonJS implementation remains only for the legacy v3/v4
+ * formats, which the native engine does not cover. Set
+ * `STEGDOC_DISABLE_NATIVE=1` to force the JS paths.
+ *
+ * @returns {object|null} The binding, or null when unavailable.
+ */
+function loadNative() {
+  if (resolved) return binding;
+  resolved = true;
+
+  if (process.env.STEGDOC_DISABLE_NATIVE === '1') {
+    binding = null;
+    return binding;
+  }
+
+  const explicit = process.env.STEGDOC_NATIVE_PATH;
+  if (explicit) {
+    binding = require(explicit);
+    return binding;
+  }
+
+  const target = hostTarget();
+  if (target) {
+    try {
+      binding = require(packageName(target));
+      return binding;
+    } catch {
+      // Not installed; fall through to the development build.
+    }
+  }
+
+  try {
+    binding = require(path.join(NATIVE_DIR, 'stegdoc.node'));
+  } catch {
+    binding = null;
+  }
+  return binding;
+}
+
+/**
+ * @returns {boolean} Whether the native engine is loaded.
+ */
+function nativeAvailable() {
+  return loadNative() !== null;
+}
+
+module.exports = { loadNative, nativeAvailable };

package/src/lib/streams.js

@@ -1,65 +1,6 @@
 const { Transform, Writable } = require('stream');
 const crypto = require('crypto');
 
-/**
- * Transform stream that converts binary input to base64 text output.
- * Buffers incomplete 3-byte groups across chunk boundaries.
- */
-class Base64EncodeTransform extends Transform {
-  constructor() {
-    super();
-    this._remainder = Buffer.alloc(0);
-  }
-
-  _transform(chunk, encoding, callback) {
-    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-    const combined = this._remainder.length > 0 ? Buffer.concat([this._remainder, buf]) : buf;
-    const usable = combined.length - (combined.length % 3);
-    if (usable > 0) {
-      this.push(combined.slice(0, usable).toString('base64'));
-    }
-    this._remainder = usable < combined.length ? combined.slice(usable) : Buffer.alloc(0);
-    callback();
-  }
-
-  _flush(callback) {
-    if (this._remainder.length > 0) {
-      this.push(this._remainder.toString('base64'));
-      this._remainder = Buffer.alloc(0);
-    }
-    callback();
-  }
-}
-
-/**
- * Transform stream that converts base64 text input to binary output.
- * Buffers incomplete 4-char groups across chunk boundaries.
- */
-class Base64DecodeTransform extends Transform {
-  constructor() {
-    super();
-    this._remainder = '';
-  }
-
-  _transform(chunk, encoding, callback) {
-    const str = this._remainder + (Buffer.isBuffer(chunk) ? chunk.toString() : chunk);
-    const usable = str.length - (str.length % 4);
-    if (usable > 0) {
-      this.push(Buffer.from(str.slice(0, usable), 'base64'));
-    }
-    this._remainder = usable < str.length ? str.slice(usable) : '';
-    callback();
-  }
-
-  _flush(callback) {
-    if (this._remainder.length > 0) {
-      this.push(Buffer.from(this._remainder, 'base64'));
-      this._remainder = '';
-    }
-    callback();
-  }
-}
-
 /**
  * Transform stream that passes data through unchanged while computing SHA-256 hash.
  * Access the hex hash via .digest after the stream has ended.
@@ -90,51 +31,6 @@ class HashPassthrough extends Transform {
   }
 }
 
-/**
- * Writable stream that collects string output up to maxBytes.
- * Calls an async onChunkReady callback when a chunk is full, applying
- * backpressure to pause upstream until the callback resolves.
- */
-class ChunkCollector extends Writable {
-  constructor(maxBytes, onChunkReady) {
-    super({ decodeStrings: false });
-    this._maxBytes = maxBytes;
-    this._buffer = '';
-    this._chunkIndex = 0;
-    this._onChunkReady = onChunkReady;
-  }
-
-  async _write(chunk, encoding, callback) {
-    try {
-      this._buffer += typeof chunk === 'string' ? chunk : chunk.toString();
-      while (this._buffer.length >= this._maxBytes) {
-        const piece = this._buffer.slice(0, this._maxBytes);
-        this._buffer = this._buffer.slice(this._maxBytes);
-        await this._onChunkReady(piece, this._chunkIndex++);
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  async _final(callback) {
-    try {
-      if (this._buffer.length > 0) {
-        await this._onChunkReady(this._buffer, this._chunkIndex++);
-        this._buffer = '';
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  get totalChunks() {
-    return this._chunkIndex;
-  }
-}
-
 /**
  * Writable stream that collects binary Buffer output up to maxBytes.
  * Calls an async onChunkReady callback with a Buffer when full.
@@ -221,10 +117,7 @@ class ProgressTransform extends Transform {
 }
 
 module.exports = {
-  Base64EncodeTransform,
-  Base64DecodeTransform,
   HashPassthrough,
-  ChunkCollector,
   BinaryChunkCollector,
   ProgressTransform,
 };

package/src/lib/utils.js

@@ -213,6 +213,25 @@ function detectFormat(filename) {
   return null;
 }
 
+/**
+ * Reduce a metadata-supplied name to a bare, safe filename.
+ *
+ * `originalFilename` is unauthenticated, so it is never joined onto a directory
+ * unchecked (FORMAT.md 11.1). Any directory component is discarded and the
+ * remainder must not be empty, `.`, `..`, or contain NUL.
+ *
+ * @param {string} name - Metadata-supplied filename
+ * @returns {string} A bare filename safe to join onto a directory
+ * @throws {Error} If the name has no usable filename component
+ */
+function safeFilename(name) {
+  const last = String(name == null ? '' : name).split(/[/\\]/).pop();
+  if (!last || last === '.' || last === '..' || last.includes('\0')) {
+    throw new Error(`Unsafe output filename in metadata: ${JSON.stringify(name)}`);
+  }
+  return last;
+}
+
 module.exports = {
   generateHash,
   generateContentHash,
@@ -221,6 +240,7 @@ module.exports = {
   generateFilename,
   parseFilename,
   detectFormat,
+  safeFilename,
   // Legacy aliases for backward compatibility
   generateDocxFilename,
   parseDocxFilename,

package/src/lib/xlsx-writer.js

@@ -295,4 +295,14 @@ module.exports = {
   buildSheetXml,
   escapeXml,
   colLetter,
+  // Raw OOXML parts, exported so spec/tools/generate-xlsx-static.js can emit
+  // the Rust writer's constants from this frozen implementation.
+  CONTENT_TYPES,
+  RELS,
+  WORKBOOK_RELS,
+  STYLES,
+  THEME,
+  makeWorkbook,
+  makeCoreProps,
+  makeAppProps,
 };

package/src/lib/file-handler.js

@@ -1,113 +0,0 @@
-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,
-};