obscr 0.1.1 → 0.2.1

package/bin/utils/crypto.js

@@ -1,4 +1,10 @@
 const crypto = require("crypto");
+const zlib = require("zlib");
+const { promisify } = require("util");
+
+const gzipAsync = promisify(zlib.gzip);
+const gunzipAsync = promisify(zlib.gunzip);
+const pbkdf2Async = promisify(crypto.pbkdf2);
 
 const cryptoConfig = {
   cipherAlgorithm: "aes-256-gcm",
@@ -10,9 +16,16 @@ const cryptoConfig = {
   digest: "sha512",
 };
 
-const encrypt = (message, password) => {
+/**
+ * Encrypts a message using AES-256-GCM with optional compression
+ * @param {string} message - The message to encrypt
+ * @param {string} password - The password to use for encryption
+ * @param {boolean} compress - Whether to compress the message before encryption
+ * @returns {Promise<string>} The encrypted message in format: salt:nonce:ciphertext:tag[:compressed]
+ */
+const encrypt = async (message, password, compress = false) => {
   const salt = crypto.randomBytes(cryptoConfig.saltLength);
-  const key = crypto.pbkdf2Sync(
+  const key = await pbkdf2Async(
     password,
     salt,
     cryptoConfig.iterations,
@@ -20,6 +33,13 @@ const encrypt = (message, password) => {
     cryptoConfig.digest
   );
 
+  let dataToEncrypt = Buffer.from(message, "utf8");
+
+  // Compress if requested
+  if (compress) {
+    dataToEncrypt = await gzipAsync(dataToEncrypt);
+  }
+
   const nonce = crypto.randomBytes(cryptoConfig.nonceLength);
   const cipher = crypto.createCipheriv(
     cryptoConfig.cipherAlgorithm,
@@ -27,31 +47,40 @@ const encrypt = (message, password) => {
     nonce
   );
 
-  let encryptedBase64 = "";
-  cipher.setEncoding("base64");
-  cipher.on("data", (chunk) => (encryptedBase64 += chunk));
-  cipher.on("end", () => {
-    // do nothing console.log(encryptedBase64);
-    // Prints: some clear text data
-  });
-  cipher.write(message);
-  cipher.end();
+  const encryptedChunks = [];
+  encryptedChunks.push(cipher.update(dataToEncrypt));
+  encryptedChunks.push(cipher.final());
+  const encrypted = Buffer.concat(encryptedChunks);
 
   const saltBase64 = base64Encoding(salt);
   const nonceBase64 = base64Encoding(nonce);
+  const encryptedBase64 = base64Encoding(encrypted);
   const gcmTagBase64 = base64Encoding(cipher.getAuthTag());
-  return (
-    saltBase64 + ":" + nonceBase64 + ":" + encryptedBase64 + ":" + gcmTagBase64
-  );
+
+  // Add compression flag to the end for backward compatibility
+  const compressionFlag = compress ? ":1" : "";
+  return `${saltBase64}:${nonceBase64}:${encryptedBase64}:${gcmTagBase64}${compressionFlag}`;
 };
 
-const decrypt = (encrypted, password) => {
+/**
+ * Decrypts an encrypted message
+ * @param {string} encrypted - The encrypted message string
+ * @param {string} password - The password to use for decryption
+ * @returns {Promise<string>} The decrypted message
+ * @throws {Error} If decryption fails
+ */
+const decrypt = async (encrypted, password) => {
   const dataSplit = encrypted.split(":");
+
+  // Check if compression flag is present (backward compatible)
+  const isCompressed = dataSplit.length === 5 && dataSplit[4] === "1";
+
   const salt = base64Decoding(dataSplit[0]);
   const nonce = base64Decoding(dataSplit[1]);
   const ciphertext = dataSplit[2];
   const gcmTag = base64Decoding(dataSplit[3]);
-  const key = crypto.pbkdf2Sync(
+
+  const key = await pbkdf2Async(
     password,
     salt,
     cryptoConfig.iterations,
@@ -66,25 +95,35 @@ const decrypt = (encrypted, password) => {
   );
   decipher.setAuthTag(gcmTag);
 
-  let decrypted = "";
-  decipher.on("readable", () => {
-    while (null !== (chunk = decipher.read())) {
-      decrypted += chunk.toString("utf8");
+  try {
+    const decryptedChunks = [];
+    decryptedChunks.push(decipher.update(Buffer.from(ciphertext, "base64")));
+    decryptedChunks.push(decipher.final());
+    let decrypted = Buffer.concat(decryptedChunks);
+
+    // Decompress if it was compressed
+    if (isCompressed) {
+      decrypted = await gunzipAsync(decrypted);
     }
-  });
-  decipher.on("end", () => {
-    // do nothing console.log(decrypted);
-  });
-  decipher.on("error", (err) => {
-    throw err.message;
-  });
-  decipher.write(ciphertext, "base64");
-  decipher.end();
-  return decrypted;
+
+    return decrypted.toString("utf8");
+  } catch (err) {
+    throw new Error(`Decryption failed: ${err.message}`);
+  }
 };
 
+/**
+ * Encodes a buffer to base64 string
+ * @param {Buffer} input - The buffer to encode
+ * @returns {string} Base64 encoded string
+ */
 const base64Encoding = (input) => input.toString("base64");
 
+/**
+ * Decodes a base64 string to buffer
+ * @param {string} input - The base64 string to decode
+ * @returns {Buffer} Decoded buffer
+ */
 const base64Decoding = (input) => Buffer.from(input, "base64");
 
 module.exports = { encrypt, decrypt };

package/bin/utils/steg.js

@@ -1,124 +1,231 @@
 const fs = require("fs");
-const { loadImage, createCanvas } = require("canvas");
 const { get_hashed_order, str_to_bits, bits_to_str } = require("./utils");
+const { PNG } = require("pngjs");
+
+/**
+ * Prepares data bits for writing by scrambling them with a password-based key
+ * @param {number[]} dataBits - Array of data bits to write
+ * @param {string} encryptionKey - Key for scrambling the data
+ * @param {number} totalCapacity - Total capacity of the image in bits
+ * @returns {number[]} Scrambled bit array with obfuscation
+ * @throws {Error} If data is too large for the image
+ */
+const prepare_write_data = (dataBits, encryptionKey, totalCapacity) => {
+  const dataBitsLength = dataBits.length;
+  if (dataBitsLength > totalCapacity) {
+    throw new Error(
+      `Message too large! Message requires ${dataBitsLength} bits, but image can only hold ${totalCapacity} bits. ` +
+      `Try using a larger image or enabling compression with --compress flag.`
+    );
+  }
 
-const prepare_write_data = (data_bits, enc_key, encode_len) => {
-  const data_bits_len = data_bits.length;
-  if (data_bits.length > encode_len) throw "Can not hold this much data!";
-  const result = Array(encode_len);
-  for (let i = 0; i < encode_len; i++) {
-    result[i] = Math.floor(Math.random() * 2); //obfuscation
+  // Initialize with random bits for obfuscation
+  const result = new Array(totalCapacity);
+  for (let i = 0; i < totalCapacity; i++) {
+    result[i] = Math.floor(Math.random() * 2);
   }
 
-  const order = get_hashed_order(enc_key, encode_len);
-  for (let i = 0; i < data_bits_len; i++) result[order[i]] = data_bits[i];
+  // Scramble actual data into random positions
+  const scrambledOrder = get_hashed_order(encryptionKey, totalCapacity);
+  for (let i = 0; i < dataBitsLength; i++) {
+    result[scrambledOrder[i]] = dataBits[i];
+  }
 
   return result;
 };
 
-const prepare_read_data = (data_bits, enc_key) => {
-  const data_bits_len = data_bits.length;
-  const result = Array(data_bits_len);
-  const order = get_hashed_order(enc_key, data_bits_len);
-
-  for (let i = 0; i < data_bits_len; i++) result[i] = data_bits[order[i]];
+/**
+ * Extracts and unscrambles data bits using password-based key
+ * @param {number[]} dataBits - Array of scrambled bits from image
+ * @param {string} encryptionKey - Key for unscrambling the data
+ * @returns {number[]} Unscrambled bit array
+ */
+const prepare_read_data = (dataBits, encryptionKey) => {
+  const dataBitsLength = dataBits.length;
+  const result = new Array(dataBitsLength);
+  const scrambledOrder = get_hashed_order(encryptionKey, dataBitsLength);
+
+  for (let i = 0; i < dataBitsLength; i++) {
+    result[i] = dataBits[scrambledOrder[i]];
+  }
 
   return result;
 };
 
-const get_bits_lsb = (imgData) => {
-  const result = Array();
-  for (let i = 0; i < imgData.data.length; i += 4) {
-    result.push(imgData.data[i] % 2 == 1 ? 1 : 0);
-    result.push(imgData.data[i + 1] % 2 == 1 ? 1 : 0);
-    result.push(imgData.data[i + 2] % 2 == 1 ? 1 : 0);
+/**
+ * Extracts the least significant bits from image RGB channels
+ * @param {Object} imageData - PNG image data object
+ * @returns {number[]} Array of extracted LSB bits
+ */
+const get_bits_lsb = (imageData) => {
+  const result = [];
+  // Process RGB channels (skip alpha at i+3)
+  for (let i = 0; i < imageData.data.length; i += 4) {
+    result.push(imageData.data[i] % 2 === 1 ? 1 : 0);       // Red LSB
+    result.push(imageData.data[i + 1] % 2 === 1 ? 1 : 0);   // Green LSB
+    result.push(imageData.data[i + 2] % 2 === 1 ? 1 : 0);   // Blue LSB
   }
   return result;
 };
 
-const write_lsb = (imgData, setdata) => {
-  function unsetbit(k) {
-    return k % 2 == 1 ? k - 1 : k;
+/**
+ * Writes bits to the least significant bits of image RGB channels
+ * @param {Object} imageData - PNG image data object
+ * @param {number[]} bitsToWrite - Array of bits to write
+ * @returns {Object} Modified image data
+ */
+const write_lsb = (imageData, bitsToWrite) => {
+  /**
+   * Clears the LSB of a byte value
+   * @param {number} value - Byte value
+   * @returns {number} Value with LSB cleared
+   */
+  const clearLSB = (value) => {
+    return value % 2 === 1 ? value - 1 : value;
+  };
+
+  /**
+   * Sets the LSB of a byte value
+   * @param {number} value - Byte value
+   * @returns {number} Value with LSB set
+   */
+  const setLSB = (value) => {
+    return value % 2 === 1 ? value : value + 1;
+  };
+
+  let bitIndex = 0;
+  for (let i = 0; i < imageData.data.length; i += 4) {
+    // Write to RGB channels
+    imageData.data[i] = bitsToWrite[bitIndex]
+      ? setLSB(imageData.data[i])
+      : clearLSB(imageData.data[i]);
+    imageData.data[i + 1] = bitsToWrite[bitIndex + 1]
+      ? setLSB(imageData.data[i + 1])
+      : clearLSB(imageData.data[i + 1]);
+    imageData.data[i + 2] = bitsToWrite[bitIndex + 2]
+      ? setLSB(imageData.data[i + 2])
+      : clearLSB(imageData.data[i + 2]);
+    imageData.data[i + 3] = 255; // Keep alpha channel at full opacity
+    bitIndex += 3;
   }
+  return imageData;
+};
 
-  function setbit(k) {
-    return k % 2 == 1 ? k : k + 1;
-  }
-  let j = 0;
-  for (let i = 0; i < imgData.data.length; i += 4) {
-    imgData.data[i] = setdata[j]
-      ? setbit(imgData.data[i])
-      : unsetbit(imgData.data[i]);
-    imgData.data[i + 1] = setdata[j + 1]
-      ? setbit(imgData.data[i + 1])
-      : unsetbit(imgData.data[i + 1]);
-    imgData.data[i + 2] = setdata[j + 2]
-      ? setbit(imgData.data[i + 2])
-      : unsetbit(imgData.data[i + 2]);
-    imgData.data[i + 3] = 255;
-    j += 3;
-  }
-  return imgData;
+/**
+ * Calculates the bit capacity of an image
+ * @param {Object} imageData - PNG image data object
+ * @returns {number} Capacity in bits
+ */
+const calculateImageCapacity = (imageData) => {
+  return Math.floor(imageData.data.length / 4) * 3; // 3 bits per pixel (RGB)
 };
 
-exports.extractMessageFromImage = async (imagepath, encKey) => {
-  let c, ctx, imgData;
+/**
+ * Validates that an image file exists and is readable
+ * @param {string} imagePath - Path to the image file
+ * @throws {Error} If file doesn't exist or isn't readable
+ */
+const validateImageFile = (imagePath) => {
+  if (!fs.existsSync(imagePath)) {
+    throw new Error(`Image file not found: ${imagePath}`);
+  }
 
-  try {
-    const img = await loadImage(imagepath);
-    c = createCanvas(img.width, img.height);
-    ctx = c.getContext("2d");
-    ctx.drawImage(img, 0, 0, img.width, img.height);
-    imgData = ctx.getImageData(0, 0, c.width, c.height);
-  } catch (err) {
-    return [false, err];
+  const stats = fs.statSync(imagePath);
+  if (!stats.isFile()) {
+    throw new Error(`Path is not a file: ${imagePath}`);
   }
+};
 
+/**
+ * Extracts and decrypts a hidden message from a PNG image
+ * @param {string} imagePath - Path to the PNG image
+ * @param {string} encryptionKey - Key for unscrambling the data
+ * @returns {Promise<{success: boolean, data?: string, error?: string}>} Result object
+ */
+const extractMessageFromImage = async (imagePath, encryptionKey) => {
   try {
-    const bitsStream = get_bits_lsb(imgData);
-    const decryptedBitsStream = prepare_read_data(bitsStream, encKey);
-    const msg = bits_to_str(decryptedBitsStream, 1);
-    if (msg == null)
-      return [
-        false,
-        "Message does not decrypt. Maybe due to (1) wrong password / enc method. (2) corrupted file",
-      ];
-    return [true, msg];
+    validateImageFile(imagePath);
+
+    const imageBuffer = fs.readFileSync(imagePath);
+    const imageData = PNG.sync.read(imageBuffer);
+
+    const bitsStream = get_bits_lsb(imageData);
+    const decryptedBitsStream = prepare_read_data(bitsStream, encryptionKey);
+    const message = bits_to_str(decryptedBitsStream, 1);
+
+    if (message == null) {
+      return {
+        success: false,
+        error: "Decryption failed. Possible causes: wrong password, corrupted file, or no hidden message.",
+      };
+    }
+
+    return { success: true, data: message };
   } catch (err) {
-    return [
-      false,
-      "Message does not decrypt. Maybe due to (1) wrong password / enc method. (2) corrupted file",
-    ];
+    return {
+      success: false,
+      error: err.message || "Failed to extract message from image",
+    };
   }
 };
 
-exports.encodeMessageToImage = async (imagepath, msg, encKey) => {
+/**
+ * Encodes and hides an encrypted message into a PNG image
+ * @param {string} imagePath - Path to the source PNG image
+ * @param {string} message - Encrypted message to hide
+ * @param {string} encryptionKey - Key for scrambling the data
+ * @param {string} outputPath - Path for the output image (default: "encoded.png")
+ * @returns {Promise<{success: boolean, outputPath?: string, capacity?: Object, error?: string}>} Result object
+ */
+const encodeMessageToImage = async (
+  imagePath,
+  message,
+  encryptionKey,
+  outputPath = "encoded.png"
+) => {
   try {
-    // const imageBuffer = fs.readFileSync(imagepath);
-
-    const img = await loadImage(imagepath);
-    const c = createCanvas(img.width, img.height);
-    const ctx = c.getContext("2d");
-    ctx.drawImage(img, 0, 0, img.width, img.height);
-    // console.log(c.toDataURL);
-    const imgData = ctx.getImageData(0, 0, c.width, c.height);
-    const encode_len = Math.floor(imgData.data.length / 4) * 3;
-
-    // prepare data
-    const bitStream = str_to_bits(msg, 1);
+    validateImageFile(imagePath);
+
+    const imageBuffer = fs.readFileSync(imagePath);
+    const imageData = PNG.sync.read(imageBuffer);
+
+    const totalCapacity = calculateImageCapacity(imageData);
+    const bitStream = str_to_bits(message, 1);
+
+    // Prepare capacity info for user
+    const capacityInfo = {
+      totalBits: totalCapacity,
+      usedBits: bitStream.length,
+      utilization: ((bitStream.length / totalCapacity) * 100).toFixed(2) + "%",
+    };
+
+    // This will throw if message is too large
     const encryptedBitStream = prepare_write_data(
       bitStream,
-      encKey,
-      encode_len
+      encryptionKey,
+      totalCapacity
     );
 
-    const encryptedImgData = write_lsb(imgData, encryptedBitStream);
-    ctx.putImageData(encryptedImgData, 0, 0);
-    const encodedImageBuffer = c.toBuffer("image/png");
-    fs.writeFileSync("encoded.png", encodedImageBuffer);
+    const encryptedImageData = write_lsb(imageData, encryptedBitStream);
+    const outputBuffer = PNG.sync.write(encryptedImageData);
+
+    fs.writeFileSync(outputPath, outputBuffer);
 
-    return true;
+    return {
+      success: true,
+      outputPath,
+      capacity: capacityInfo,
+    };
   } catch (err) {
-    throw err;
+    return {
+      success: false,
+      error: err.message || "Failed to encode message to image",
+    };
   }
 };
+
+module.exports = {
+  extractMessageFromImage,
+  encodeMessageToImage,
+  calculateImageCapacity,
+};