stegdoc 4.0.0 → 5.0.1

package/src/lib/metadata.js

@@ -1,122 +1,151 @@
-/**
- * Create metadata object for encoding
- * @param {object} options - Metadata options
- * @param {string} options.originalFilename - Original filename
- * @param {string} options.originalExtension - Original file extension
- * @param {string} options.hash - Hash identifier for this file
- * @param {number} options.partNumber - Part number (for split files)
- * @param {number} options.totalParts - Total number of parts
- * @param {number} options.originalSize - Original file size in bytes
- * @param {string} options.format - Output format ('xlsx' or 'docx')
- * @param {boolean} options.encrypted - Whether the content is encrypted
- * @param {boolean} options.compressed - Whether the content is compressed
- * @param {string} options.contentHash - SHA-256 hash of original file for integrity verification
- * @returns {object} Metadata object
- */
-function createMetadata({
-  originalFilename,
-  originalExtension,
-  hash,
-  partNumber = null,
-  totalParts = null,
-  originalSize = 0,
-  format = 'xlsx',
-  encrypted = true,
-  compressed = false,
-  contentHash = null,
-}) {
-  return {
-    originalFilename,
-    originalExtension,
-    hash,
-    partNumber,
-    totalParts,
-    originalSize,
-    format,
-    encrypted,
-    compressed,
-    contentHash,
-    pipelineOrder: 'compress-encrypt-base64',
-    encodingDate: new Date().toISOString(),
-    version: '4.0.0',
-    tool: 'stegdoc',
-  };
-}
-
-/**
- * Serialize metadata to string format for storage in DOCX
- * @param {object} metadata - Metadata object
- * @returns {string} JSON string
- */
-function serializeMetadata(metadata) {
-  return JSON.stringify(metadata);
-}
-
-/**
- * Parse metadata from string
- * @param {string} metadataStr - JSON string
- * @returns {object} Metadata object
- */
-function parseMetadata(metadataStr) {
-  try {
-    return JSON.parse(metadataStr);
-  } catch (error) {
-    throw new Error(`Failed to parse metadata: ${error.message}`);
-  }
-}
-
-/**
- * Validate metadata object
- * @param {object} metadata - Metadata to validate
- * @returns {boolean} True if valid
- * @throws {Error} If metadata is invalid
- */
-function validateMetadata(metadata) {
-  const required = ['originalFilename', 'originalExtension', 'hash', 'tool'];
-
-  for (const field of required) {
-    if (!metadata[field]) {
-      throw new Error(`Missing required metadata field: ${field}`);
-    }
-  }
-
-  if (metadata.tool !== 'stegdoc' && metadata.tool !== 'whitener') {
-    throw new Error('Invalid tool identifier in metadata');
-  }
-
-  // If it's a multi-part file, validate part info
-  if (metadata.totalParts !== null && metadata.totalParts > 1) {
-    if (metadata.partNumber === null || metadata.partNumber < 1 || metadata.partNumber > metadata.totalParts) {
-      throw new Error('Invalid part number in metadata');
-    }
-  }
-
-  return true;
-}
-
-/**
- * Check if metadata indicates a multi-part file
- * @param {object} metadata - Metadata object
- * @returns {boolean} True if multi-part
- */
-function isMultiPart(metadata) {
-  return metadata.totalParts !== null && metadata.totalParts > 1;
-}
-
-/**
- * Check if metadata indicates the v4 streaming format
- * @param {object} metadata - Metadata object
- * @returns {boolean} True if streaming format (v4+)
- */
-function isStreamingFormat(metadata) {
-  return metadata.pipelineOrder === 'compress-encrypt-base64';
-}
-
-module.exports = {
-  createMetadata,
-  serializeMetadata,
-  parseMetadata,
-  validateMetadata,
-  isMultiPart,
-  isStreamingFormat,
-};
+/**
+ * Create metadata object for encoding
+ * @param {object} options - Metadata options
+ * @param {string} options.originalFilename - Original filename
+ * @param {string} options.originalExtension - Original file extension
+ * @param {string} options.hash - Hash identifier for this file
+ * @param {number} options.partNumber - Part number (for split files)
+ * @param {number} options.totalParts - Total number of parts
+ * @param {number} options.originalSize - Original file size in bytes
+ * @param {string} options.format - Output format ('xlsx' or 'docx')
+ * @param {boolean} options.encrypted - Whether the content is encrypted
+ * @param {boolean} options.compressed - Whether the content is compressed
+ * @param {string} options.contentHash - SHA-256 hash of original file for integrity verification
+ * @returns {object} Metadata object
+ */
+function createMetadata({
+  originalFilename,
+  originalExtension,
+  hash,
+  partNumber = null,
+  totalParts = null,
+  originalSize = 0,
+  format = 'xlsx',
+  encrypted = true,
+  compressed = false,
+  contentHash = null,
+  // v5 fields
+  stegoMethod = null,
+  compressionAlgo = null,
+  payloadSize = null,
+  dataLineCount = null,
+  headerLineCount = null,
+}) {
+  const isV5 = stegoMethod === 'log-embed';
+
+  const meta = {
+    originalFilename,
+    originalExtension,
+    hash,
+    partNumber,
+    totalParts,
+    originalSize,
+    format,
+    encrypted,
+    compressed,
+    contentHash,
+    pipelineOrder: isV5 ? 'brotli-encrypt-logEmbed' : 'compress-encrypt-base64',
+    encodingDate: new Date().toISOString(),
+    version: isV5 ? '5.0.0' : '4.0.0',
+    tool: 'stegdoc',
+  };
+
+  // v5-specific fields
+  if (isV5) {
+    meta.stegoMethod = 'log-embed';
+    meta.compressionAlgo = compressionAlgo || 'brotli';
+    if (payloadSize !== null) meta.payloadSize = payloadSize;
+    if (dataLineCount !== null) meta.dataLineCount = dataLineCount;
+    if (headerLineCount !== null) meta.headerLineCount = headerLineCount;
+  }
+
+  return meta;
+}
+
+/**
+ * Serialize metadata to string format for storage in DOCX
+ * @param {object} metadata - Metadata object
+ * @returns {string} JSON string
+ */
+function serializeMetadata(metadata) {
+  return JSON.stringify(metadata);
+}
+
+/**
+ * Parse metadata from string
+ * @param {string} metadataStr - JSON string
+ * @returns {object} Metadata object
+ */
+function parseMetadata(metadataStr) {
+  try {
+    return JSON.parse(metadataStr);
+  } catch (error) {
+    throw new Error(`Failed to parse metadata: ${error.message}`);
+  }
+}
+
+/**
+ * Validate metadata object
+ * @param {object} metadata - Metadata to validate
+ * @returns {boolean} True if valid
+ * @throws {Error} If metadata is invalid
+ */
+function validateMetadata(metadata) {
+  const required = ['originalFilename', 'originalExtension', 'hash', 'tool'];
+
+  for (const field of required) {
+    if (!metadata[field]) {
+      throw new Error(`Missing required metadata field: ${field}`);
+    }
+  }
+
+  if (metadata.tool !== 'stegdoc' && metadata.tool !== 'whitener') {
+    throw new Error('Invalid tool identifier in metadata');
+  }
+
+  // If it's a multi-part file, validate part info
+  if (metadata.totalParts !== null && metadata.totalParts > 1) {
+    if (metadata.partNumber === null || metadata.partNumber < 1 || metadata.partNumber > metadata.totalParts) {
+      throw new Error('Invalid part number in metadata');
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Check if metadata indicates a multi-part file
+ * @param {object} metadata - Metadata object
+ * @returns {boolean} True if multi-part
+ */
+function isMultiPart(metadata) {
+  return metadata.totalParts !== null && metadata.totalParts > 1;
+}
+
+/**
+ * Check if metadata indicates the v4 streaming format
+ * @param {object} metadata - Metadata object
+ * @returns {boolean} True if streaming format (v4+)
+ */
+function isStreamingFormat(metadata) {
+  return metadata.pipelineOrder === 'compress-encrypt-base64';
+}
+
+/**
+ * Check if metadata indicates the v5 log-embed format
+ * @param {object} metadata - Metadata object
+ * @returns {boolean} True if log-embed format (v5+)
+ */
+function isLogEmbedFormat(metadata) {
+  return metadata.stegoMethod === 'log-embed' || metadata.pipelineOrder === 'brotli-encrypt-logEmbed';
+}
+
+module.exports = {
+  createMetadata,
+  serializeMetadata,
+  parseMetadata,
+  validateMetadata,
+  isMultiPart,
+  isStreamingFormat,
+  isLogEmbedFormat,
+};

package/src/lib/streams.js

@@ -1,197 +1,197 @@
-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.
- */
-class HashPassthrough extends Transform {
-  constructor() {
-    super();
-    this._hash = crypto.createHash('sha256');
-    this._finalized = false;
-  }
-
-  _transform(chunk, encoding, callback) {
-    this._hash.update(chunk);
-    this.push(chunk);
-    callback();
-  }
-
-  _flush(callback) {
-    this._finalized = true;
-    callback();
-  }
-
-  get digest() {
-    if (!this._finalized) {
-      throw new Error('Cannot read digest before stream has ended');
-    }
-    return this._hash.digest('hex');
-  }
-}
-
-/**
- * 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.
- */
-class BinaryChunkCollector extends Writable {
-  constructor(maxBytes, onChunkReady) {
-    super();
-    this._maxBytes = maxBytes;
-    this._buffers = [];
-    this._currentSize = 0;
-    this._chunkIndex = 0;
-    this._onChunkReady = onChunkReady;
-  }
-
-  async _write(chunk, encoding, callback) {
-    try {
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-      this._buffers.push(buf);
-      this._currentSize += buf.length;
-
-      while (this._currentSize >= this._maxBytes) {
-        const combined = Buffer.concat(this._buffers);
-        const piece = combined.slice(0, this._maxBytes);
-        const leftover = combined.slice(this._maxBytes);
-        this._buffers = leftover.length > 0 ? [leftover] : [];
-        this._currentSize = leftover.length;
-        await this._onChunkReady(piece, this._chunkIndex++);
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  async _final(callback) {
-    try {
-      if (this._currentSize > 0) {
-        const combined = Buffer.concat(this._buffers);
-        await this._onChunkReady(combined, this._chunkIndex++);
-        this._buffers = [];
-        this._currentSize = 0;
-      }
-      callback();
-    } catch (err) {
-      callback(err);
-    }
-  }
-
-  get totalChunks() {
-    return this._chunkIndex;
-  }
-}
-
-module.exports = {
-  Base64EncodeTransform,
-  Base64DecodeTransform,
-  HashPassthrough,
-  ChunkCollector,
-  BinaryChunkCollector,
-};
+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.
+ */
+class HashPassthrough extends Transform {
+  constructor() {
+    super();
+    this._hash = crypto.createHash('sha256');
+    this._finalized = false;
+  }
+
+  _transform(chunk, encoding, callback) {
+    this._hash.update(chunk);
+    this.push(chunk);
+    callback();
+  }
+
+  _flush(callback) {
+    this._finalized = true;
+    callback();
+  }
+
+  get digest() {
+    if (!this._finalized) {
+      throw new Error('Cannot read digest before stream has ended');
+    }
+    return this._hash.digest('hex');
+  }
+}
+
+/**
+ * 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.
+ */
+class BinaryChunkCollector extends Writable {
+  constructor(maxBytes, onChunkReady) {
+    super();
+    this._maxBytes = maxBytes;
+    this._buffers = [];
+    this._currentSize = 0;
+    this._chunkIndex = 0;
+    this._onChunkReady = onChunkReady;
+  }
+
+  async _write(chunk, encoding, callback) {
+    try {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+      this._buffers.push(buf);
+      this._currentSize += buf.length;
+
+      while (this._currentSize >= this._maxBytes) {
+        const combined = Buffer.concat(this._buffers);
+        const piece = combined.slice(0, this._maxBytes);
+        const leftover = combined.slice(this._maxBytes);
+        this._buffers = leftover.length > 0 ? [leftover] : [];
+        this._currentSize = leftover.length;
+        await this._onChunkReady(piece, this._chunkIndex++);
+      }
+      callback();
+    } catch (err) {
+      callback(err);
+    }
+  }
+
+  async _final(callback) {
+    try {
+      if (this._currentSize > 0) {
+        const combined = Buffer.concat(this._buffers);
+        await this._onChunkReady(combined, this._chunkIndex++);
+        this._buffers = [];
+        this._currentSize = 0;
+      }
+      callback();
+    } catch (err) {
+      callback(err);
+    }
+  }
+
+  get totalChunks() {
+    return this._chunkIndex;
+  }
+}
+
+module.exports = {
+  Base64EncodeTransform,
+  Base64DecodeTransform,
+  HashPassthrough,
+  ChunkCollector,
+  BinaryChunkCollector,
+};