obscr 0.1.2 → 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

@@ -2,115 +2,230 @@ const fs = require("fs");
 const { get_hashed_order, str_to_bits, bits_to_str } = require("./utils");
 const { PNG } = require("pngjs");
 
-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
+/**
+ * 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.`
+    );
+  }
+
+  // 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 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 imageBuffer = fs.readFileSync(imagepath);
-    imgData = PNG.sync.read(imageBuffer);
-  } 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 imgData = PNG.sync.read(imageBuffer);
+    validateImageFile(imagePath);
+
+    const imageBuffer = fs.readFileSync(imagePath);
+    const imageData = PNG.sync.read(imageBuffer);
+
+    const totalCapacity = calculateImageCapacity(imageData);
+    const bitStream = str_to_bits(message, 1);
 
-    const encode_len = Math.floor(imgData.data.length / 4) * 3;
+    // Prepare capacity info for user
+    const capacityInfo = {
+      totalBits: totalCapacity,
+      usedBits: bitStream.length,
+      utilization: ((bitStream.length / totalCapacity) * 100).toFixed(2) + "%",
+    };
 
-    // prepare data
-    const bitStream = str_to_bits(msg, 1);
+    // 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);
-    let buff = PNG.sync.write(encryptedImgData);
+    const encryptedImageData = write_lsb(imageData, encryptedBitStream);
+    const outputBuffer = PNG.sync.write(encryptedImageData);
 
-    fs.writeFileSync("encoded.png", buff);
+    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,
+};

package/bin/utils/utils.js

@@ -1,45 +1,59 @@
 const { MersenneTwister } = require("./mersenne-twister");
 const SHA512 = require("crypto-js/sha512");
 
-const get_hashed_order = (password, arr_len) => {
-  // O(arr_len) algorithm
-  const orders = Array.from(Array(arr_len).keys());
+/**
+ * Generates a hashed order array for data scrambling using password-based seeding
+ * @param {string} password - The password to generate the seed from
+ * @param {number} arrayLength - The length of the order array to generate
+ * @returns {number[]} Array of indices in scrambled order
+ */
+const get_hashed_order = (password, arrayLength) => {
+  // O(arrayLength) algorithm using Fisher-Yates shuffle
+  const orders = Array.from(Array(arrayLength).keys());
   const result = [];
-  let loc;
-  const seed = SHA512(password).words.reduce(function (total, num) {
+  let location;
+  const seed = SHA512(password).words.reduce((total, num) => {
     return total + Math.abs(num);
   }, 0);
-  const rnd = new MersenneTwister(seed);
-  for (let i = arr_len; i > 0; i--) {
-    loc = rnd.genrand_int32() % i;
-    result.push(orders[loc]);
-    orders[loc] = orders[i - 1];
+  const rng = new MersenneTwister(seed);
+  for (let i = arrayLength; i > 0; i--) {
+    location = rng.genrand_int32() % i;
+    result.push(orders[location]);
+    orders[location] = orders[i - 1];
   }
   return result;
 };
 
+/**
+ * Decodes a UTF-8 byte array to a string
+ * @param {number[]} bytes - Array of byte values
+ * @returns {string} Decoded UTF-8 string
+ */
 const utf8Decode = (bytes) => {
-  var chars = [],
-    offset = 0,
-    length = bytes.length,
-    c,
-    c2,
-    c3;
+  const chars = [];
+  let offset = 0;
+  const length = bytes.length;
+  let currentByte, secondByte, thirdByte;
 
   while (offset < length) {
-    c = bytes[offset];
-    c2 = bytes[offset + 1];
-    c3 = bytes[offset + 2];
+    currentByte = bytes[offset];
+    secondByte = bytes[offset + 1];
+    thirdByte = bytes[offset + 2];
 
-    if (128 > c) {
-      chars.push(String.fromCharCode(c));
+    if (128 > currentByte) {
+      // Single-byte character (ASCII)
+      chars.push(String.fromCharCode(currentByte));
       offset += 1;
-    } else if (191 < c && c < 224) {
-      chars.push(String.fromCharCode(((c & 31) << 6) | (c2 & 63)));
+    } else if (191 < currentByte && currentByte < 224) {
+      // Two-byte character
+      chars.push(String.fromCharCode(((currentByte & 31) << 6) | (secondByte & 63)));
       offset += 2;
     } else {
+      // Three-byte character
       chars.push(
-        String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63))
+        String.fromCharCode(
+          ((currentByte & 15) << 12) | ((secondByte & 63) << 6) | (thirdByte & 63)
+        )
       );
       offset += 3;
     }
@@ -48,11 +62,16 @@ const utf8Decode = (bytes) => {
   return chars.join("");
 };
 
+/**
+ * Encodes a string to a UTF-8 byte array
+ * @param {string} str - The string to encode
+ * @returns {number[]} Array of byte values
+ */
 const utf8Encode = (str) => {
-  var bytes = [],
-    offset = 0,
-    length,
-    char;
+  const bytes = [];
+  let offset = 0;
+  let length;
+  let char;
 
   str = encodeURI(str);
   length = str.length;
@@ -73,51 +92,81 @@ const utf8Encode = (str) => {
   return bytes;
 };
 
-const bits_to_str = (bitarray, num_copy) => {
-  function merge_bits(bits) {
-    var bits_len = bits.length;
-    var bits_sum = 0;
-    for (var i = 0; i < bits_len; i++) bits_sum += bits[i];
-    return Math.round(bits_sum / bits_len);
-  }
-
-  var msg_array = Array();
-  var data, tmp;
-
-  var msg_array_len = Math.floor(Math.floor(bitarray.length / num_copy) / 8);
-  for (var i = 0; i < msg_array_len; i++) {
-    data = 0;
-    tmp = 128;
-    for (var j = 0; j < 8; j++) {
-      data +=
-        merge_bits(
-          bitarray.slice((i * 8 + j) * num_copy, (i * 8 + j + 1) * num_copy)
-        ) * tmp;
-      tmp = Math.floor(tmp / 2);
+/**
+ * Converts a bit array to a string using majority voting for error correction
+ * @param {number[]} bitArray - Array of bits (0s and 1s)
+ * @param {number} numCopies - Number of redundant copies per bit for error correction
+ * @returns {string} Decoded string
+ */
+const bits_to_str = (bitArray, numCopies) => {
+  /**
+   * Merges multiple copies of a bit using majority voting
+   * @param {number[]} bits - Array of bit copies
+   * @returns {number} 0 or 1 based on majority
+   */
+  const mergeBits = (bits) => {
+    const bitsLength = bits.length;
+    let bitsSum = 0;
+    for (let i = 0; i < bitsLength; i++) {
+      bitsSum += bits[i];
     }
-    if (data == 255) break; //END NOTATION
-    msg_array.push(data);
+    return Math.round(bitsSum / bitsLength);
+  };
+
+  const messageArray = [];
+  let byteValue, powerOfTwo;
+
+  const messageArrayLength = Math.floor(Math.floor(bitArray.length / numCopies) / 8);
+  for (let i = 0; i < messageArrayLength; i++) {
+    byteValue = 0;
+    powerOfTwo = 128;
+    for (let j = 0; j < 8; j++) {
+      byteValue +=
+        mergeBits(
+          bitArray.slice((i * 8 + j) * numCopies, (i * 8 + j + 1) * numCopies)
+        ) * powerOfTwo;
+      powerOfTwo = Math.floor(powerOfTwo / 2);
+    }
+    if (byteValue === 255) break; // END NOTATION
+    messageArray.push(byteValue);
   }
 
-  return utf8Decode(msg_array);
+  return utf8Decode(messageArray);
 };
 
-const str_to_bits = (str, num_copy) => {
-  const utf8array = utf8Encode(str);
-  const result = Array();
-  const utf8strlen = utf8array.length;
-  for (let i = 0; i < utf8strlen; i++) {
-    for (let j = 128; j > 0; j = Math.floor(j / 2)) {
-      if (Math.floor(utf8array[i] / j)) {
-        for (let cp = 0; cp < num_copy; cp++) result.push(1);
-        utf8array[i] -= j;
-      } else for (let cp = 0; cp < num_copy; cp++) result.push(0);
+/**
+ * Converts a string to a bit array with redundant copies for error correction
+ * @param {string} str - The string to convert
+ * @param {number} numCopies - Number of redundant copies per bit
+ * @returns {number[]} Array of bits with redundancy
+ */
+const str_to_bits = (str, numCopies) => {
+  const utf8Array = utf8Encode(str);
+  const result = [];
+  const utf8Length = utf8Array.length;
+
+  for (let i = 0; i < utf8Length; i++) {
+    for (let powerOfTwo = 128; powerOfTwo > 0; powerOfTwo = Math.floor(powerOfTwo / 2)) {
+      if (Math.floor(utf8Array[i] / powerOfTwo)) {
+        for (let copy = 0; copy < numCopies; copy++) {
+          result.push(1);
+        }
+        utf8Array[i] -= powerOfTwo;
+      } else {
+        for (let copy = 0; copy < numCopies; copy++) {
+          result.push(0);
+        }
+      }
     }
   }
-  for (let j = 0; j < 24; j++)
-    for (let i = 0; i < num_copy; i++) {
+
+  // Add end marker (24 bits of 1s)
+  for (let j = 0; j < 24; j++) {
+    for (let i = 0; i < numCopies; i++) {
       result.push(1);
     }
+  }
+
   return result;
 };