obscr 0.1.1

package/.github/workflows/publish.yml

@@ -0,0 +1,18 @@
+name: Publish Package to npmjs
+on:
+  release:
+    types: [created]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      # Setup .npmrc file to publish to npm
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "16.x"
+          registry-url: "https://registry.npmjs.org"
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -0,0 +1,72 @@
+<p align="center">
+  
+ </p>
+ <p align="center">
+   <img  src="https://img.shields.io/badge/license-MIT-green">
+ <img  src="https://img.shields.io/badge/build-passing-brightgreen">
+   <img  src="https://img.shields.io/badge/version-0.1.1-orange">
+   <img  src="https://img.shields.io/badge/npm-v8.3.1-blue">
+  <img  src="https://img.shields.io/badge/node-v16.14.0-yellow">
+ </p>
+ <br>
+<p align="center">A CLI to encrypt data inside images.</p>
+<br>
+
+---
+
+## Description
+
+CLI tool to encrypt secret messages with AES-256-GCM and a password.
+Same password will then be used as a seed to generate a random order in which the encrypted message will be encoded inside the specified .png image.
+
+## NPM package
+
+```
+npm install -g obscr
+```
+
+## Usage
+
+```
+~$ obscr --help
+Usage: obscr <cmd> [options]
+
+Commands:
+  obscr encrypt  Encrypts and hides the message into an image.
+  obscr decrypt  Decrypts message from image.
+
+Options:
+  --version  Show version number                                       [boolean]
+  --help     Show help                                                 [boolean]
+
+copyright 2022
+
+```
+
+> :warning: **Only tested with png images**
+
+<br>
+
+## Installation
+
+1. Clone the repository and then navigate to it.
+2. Run `npm install` to install the dependencies.
+3. Run `npm install -g .` to install the CLI. <br>
+
+> :warning: **This might cause an error** which can be resolved easily by using `sudo` with the command, **however**, using `sudo` with `npm` is **not recommended** because it might cause permission issues later. So instead put the code below in your .bashrc file and then run the above command again.
+
+```
+npm set prefix ~/.npm
+PATH="$HOME/.npm/bin:$PATH"
+PATH="./node_modules/.bin:$PATH"
+```
+
+4. Now you are good to go and can use the CLI globally!
+
+Type `obscr` or `obscr --help` to get started.
+
+<br>
+
+## License
+
+MIT © **_Obscr_**

package/bin/index.js

@@ -0,0 +1,157 @@
+#! /usr/bin/env node
+const yargs = require("yargs");
+const chalk = require("chalk");
+const fs = require("fs");
+
+const { prompt } = require("inquirer");
+
+const { encrypt, decrypt } = require("./utils/crypto");
+const {
+  encodeMessageToImage,
+  extractMessageFromImage,
+} = require("./utils/steg");
+
+//just to increase obfuscation for steg, not actually used for the AES encryption
+const SECRET_KEY = "S3cReTK3Y";
+
+const usage = chalk.keyword("violet")("\nUsage: obscr <cmd> [options]");
+
+const options = yargs
+  .usage(usage)
+
+  // Create encrypt command
+  .command(
+    "encrypt",
+    "Encrypts and hides the message into an image.",
+    {
+      f: {
+        alias: "filename",
+        describe: "Name of the png image to hide the message in",
+        demandOption: true, // Required
+        type: "string",
+      },
+      c: {
+        alias: "compress",
+        describe: "Compress the secret message",
+        demandOption: false,
+        type: "string",
+      },
+    },
+
+    async (argv) => {
+      const { f: filename, c: compress } = argv;
+
+      const { password, confirmPassword, message } = await prompt([
+        {
+          type: "editor",
+          name: "message",
+          message: "Type the secret message",
+        },
+        {
+          type: "password",
+          name: "password",
+          message: "Enter Password:",
+        },
+        {
+          type: "password",
+          name: "confirmPassword",
+          message: "Re-type Password:",
+        },
+      ]);
+
+      // config.set({ token });
+      if (password !== confirmPassword) {
+        return console.log(chalk.keyword("red")("Passwords don't match"));
+      }
+
+      /*
+        #1. encrypt message with key using AES-256-GCM
+      */
+
+      try {
+        const encrypted = encrypt(message, password);
+        console.log(encrypted);
+        await encodeMessageToImage(filename, encrypted, password + SECRET_KEY);
+      } catch (e) {
+        return console.log(chalk.keyword("red")(e.message));
+      }
+
+      /*
+        #2. embed encrypted message scattered into image
+      */
+
+      console.log(chalk.keyword("green")("Successful"));
+    }
+  )
+  //create decrypt command
+  .command(
+    "decrypt",
+    "Decrypts message from image.",
+    {
+      f: {
+        alias: "filename",
+        describe: "Name of the png image to hide the message in",
+        demandOption: true, // Required
+        type: "string",
+      },
+      o: {
+        alias: "output",
+        describe: "Output filename",
+        demandOption: false, // Required
+        type: "string",
+      },
+    },
+
+    async (argv) => {
+      const { f: filename, o: output } = argv;
+
+      const { password } = await prompt({
+        type: "password",
+        name: "password",
+        message: "Enter Password:",
+      });
+
+      /*
+        #2. extract encrypted message from image
+      */
+
+      /*
+        #1. decrypt message with key using AES-256-GCM
+      */
+
+      try {
+        const [succeeded, extracted] = await extractMessageFromImage(
+          filename,
+          password + SECRET_KEY
+        );
+
+        if (!succeeded) throw extracted;
+        const decrypted = decrypt(extracted, password);
+
+        console.log(decrypted);
+
+        if (output) fs.writeFileSync(output, decrypted);
+      } catch (e) {
+        console.log(e);
+        return console.log(chalk.keyword("red")("Could not decrypt"));
+      }
+
+      console.log(chalk.keyword("green")("Successful"));
+    }
+  )
+
+  .epilog("copyright 2022")
+  .help(true).argv;
+
+if (yargs.argv._[0] == null) {
+  yargs.showHelp();
+  process.exit(0);
+}
+
+/*
+TODO: error out if image is too small
+TODO: implement compression
+TODO: implement streaming
+TODO: file encryption
+
+*/

package/bin/utils/crypto.js

@@ -0,0 +1,90 @@
+const crypto = require("crypto");
+
+const cryptoConfig = {
+  cipherAlgorithm: "aes-256-gcm",
+  iterations: 65535,
+  keyLength: 32,
+  saltLength: 32,
+  nonceLength: 12,
+  tagLength: 16,
+  digest: "sha512",
+};
+
+const encrypt = (message, password) => {
+  const salt = crypto.randomBytes(cryptoConfig.saltLength);
+  const key = crypto.pbkdf2Sync(
+    password,
+    salt,
+    cryptoConfig.iterations,
+    cryptoConfig.keyLength,
+    cryptoConfig.digest
+  );
+
+  const nonce = crypto.randomBytes(cryptoConfig.nonceLength);
+  const cipher = crypto.createCipheriv(
+    cryptoConfig.cipherAlgorithm,
+    key,
+    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 saltBase64 = base64Encoding(salt);
+  const nonceBase64 = base64Encoding(nonce);
+  const gcmTagBase64 = base64Encoding(cipher.getAuthTag());
+  return (
+    saltBase64 + ":" + nonceBase64 + ":" + encryptedBase64 + ":" + gcmTagBase64
+  );
+};
+
+const decrypt = (encrypted, password) => {
+  const dataSplit = encrypted.split(":");
+  const salt = base64Decoding(dataSplit[0]);
+  const nonce = base64Decoding(dataSplit[1]);
+  const ciphertext = dataSplit[2];
+  const gcmTag = base64Decoding(dataSplit[3]);
+  const key = crypto.pbkdf2Sync(
+    password,
+    salt,
+    cryptoConfig.iterations,
+    cryptoConfig.keyLength,
+    cryptoConfig.digest
+  );
+
+  const decipher = crypto.createDecipheriv(
+    cryptoConfig.cipherAlgorithm,
+    key,
+    nonce
+  );
+  decipher.setAuthTag(gcmTag);
+
+  let decrypted = "";
+  decipher.on("readable", () => {
+    while (null !== (chunk = decipher.read())) {
+      decrypted += chunk.toString("utf8");
+    }
+  });
+  decipher.on("end", () => {
+    // do nothing console.log(decrypted);
+  });
+  decipher.on("error", (err) => {
+    throw err.message;
+  });
+  decipher.write(ciphertext, "base64");
+  decipher.end();
+  return decrypted;
+};
+
+const base64Encoding = (input) => input.toString("base64");
+
+const base64Decoding = (input) => Buffer.from(input, "base64");
+
+module.exports = { encrypt, decrypt };

package/bin/utils/mersenne-twister.js

@@ -0,0 +1,187 @@
+// Code from https://gist.github.com/banksean/300494 for seeded rand.
+
+/*
+  I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
+  so it's better encapsulated. Now you can have multiple random number generators
+  and they won't stomp all over eachother's state.
+
+  If you want to use this as a substitute for Math.random(), use the random()
+  method like so:
+
+  var m = new MersenneTwister();
+  var randomNumber = m.random();
+
+  You can also call the other genrand_{foo}() methods on the instance.
+  If you want to use a specific seed in order to get a repeatable random
+  sequence, pass an integer into the constructor:
+  var m = new MersenneTwister(123);
+  and that will always produce the same random sequence.
+  Sean McCullough (banksean@gmail.com)
+*/
+
+/*
+   A C-program for MT19937, with initialization improved 2002/1/26.
+   Coded by Takuji Nishimura and Makoto Matsumoto.
+
+   Before using, initialize the state by using init_genrand(seed)
+   or init_by_array(init_key, key_length).
+
+   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+     1. Redistributions of source code must retain the above copyright
+        notice, this list of conditions and the following disclaimer.
+
+     2. Redistributions in binary form must reproduce the above copyright
+        notice, this list of conditions and the following disclaimer in the
+        documentation and/or other materials provided with the distribution.
+
+     3. The names of its contributors may not be used to endorse or promote
+        products derived from this software without specific prior written
+        permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+   Any feedback is very welcome.
+   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
+*/
+
+var MersenneTwister = function (seed) {
+  if (seed == undefined) {
+    seed = new Date().getTime();
+  }
+  /* Period parameters */
+  this.N = 624;
+  this.M = 397;
+  this.MATRIX_A = 0x9908b0df; /* constant vector a */
+  this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
+  this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
+
+  this.mt = new Array(this.N); /* the array for the state vector */
+  this.mti = this.N + 1; /* mti==N+1 means mt[N] is not initialized */
+
+  this.init_genrand(seed);
+};
+
+/* initializes mt[N] with a seed */
+MersenneTwister.prototype.init_genrand = function (s) {
+  this.mt[0] = s >>> 0;
+  for (this.mti = 1; this.mti < this.N; this.mti++) {
+    var s = this.mt[this.mti - 1] ^ (this.mt[this.mti - 1] >>> 30);
+    this.mt[this.mti] =
+      ((((s & 0xffff0000) >>> 16) * 1812433253) << 16) +
+      (s & 0x0000ffff) * 1812433253 +
+      this.mti;
+    /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
+    /* In the previous versions, MSBs of the seed affect   */
+    /* only MSBs of the array mt[].                        */
+    /* 2002/01/09 modified by Makoto Matsumoto             */
+    this.mt[this.mti] >>>= 0;
+    /* for >32 bit machines */
+  }
+};
+
+/* initialize by an array with array-length */
+/* init_key is the array for initializing keys */
+/* key_length is its length */
+/* slight change for C++, 2004/2/26 */
+MersenneTwister.prototype.init_by_array = function (init_key, key_length) {
+  var i, j, k;
+  this.init_genrand(19650218);
+  i = 1;
+  j = 0;
+  k = this.N > key_length ? this.N : key_length;
+  for (; k; k--) {
+    var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+    this.mt[i] =
+      (this.mt[i] ^
+        (((((s & 0xffff0000) >>> 16) * 1664525) << 16) +
+          (s & 0x0000ffff) * 1664525)) +
+      init_key[j] +
+      j; /* non linear */
+    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+    i++;
+    j++;
+    if (i >= this.N) {
+      this.mt[0] = this.mt[this.N - 1];
+      i = 1;
+    }
+    if (j >= key_length) j = 0;
+  }
+  for (k = this.N - 1; k; k--) {
+    var s = this.mt[i - 1] ^ (this.mt[i - 1] >>> 30);
+    this.mt[i] =
+      (this.mt[i] ^
+        (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) +
+          (s & 0x0000ffff) * 1566083941)) -
+      i; /* non linear */
+    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
+    i++;
+    if (i >= this.N) {
+      this.mt[0] = this.mt[this.N - 1];
+      i = 1;
+    }
+  }
+
+  this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
+};
+
+/* generates a random number on [0,0xffffffff]-interval */
+MersenneTwister.prototype.genrand_int32 = function () {
+  var y;
+  var mag01 = new Array(0x0, this.MATRIX_A);
+  /* mag01[x] = x * MATRIX_A  for x=0,1 */
+
+  if (this.mti >= this.N) {
+    /* generate N words at one time */
+    var kk;
+
+    if (this.mti == this.N + 1)
+      /* if init_genrand() has not been called, */
+      this.init_genrand(5489); /* a default initial seed is used */
+
+    for (kk = 0; kk < this.N - this.M; kk++) {
+      y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+      this.mt[kk] = this.mt[kk + this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
+    }
+    for (; kk < this.N - 1; kk++) {
+      y = (this.mt[kk] & this.UPPER_MASK) | (this.mt[kk + 1] & this.LOWER_MASK);
+      this.mt[kk] =
+        this.mt[kk + (this.M - this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
+    }
+    y =
+      (this.mt[this.N - 1] & this.UPPER_MASK) | (this.mt[0] & this.LOWER_MASK);
+    this.mt[this.N - 1] = this.mt[this.M - 1] ^ (y >>> 1) ^ mag01[y & 0x1];
+
+    this.mti = 0;
+  }
+
+  y = this.mt[this.mti++];
+
+  /* Tempering */
+  y ^= y >>> 11;
+  y ^= (y << 7) & 0x9d2c5680;
+  y ^= (y << 15) & 0xefc60000;
+  y ^= y >>> 18;
+
+  return y >>> 0;
+};
+/* These real versions are due to Isaku Wada, 2002/01/09 added */
+
+module.exports = { MersenneTwister };

package/bin/utils/steg.js

@@ -0,0 +1,124 @@
+const fs = require("fs");
+const { loadImage, createCanvas } = require("canvas");
+const { get_hashed_order, str_to_bits, bits_to_str } = require("./utils");
+
+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
+  }
+
+  const order = get_hashed_order(enc_key, encode_len);
+  for (let i = 0; i < data_bits_len; i++) result[order[i]] = data_bits[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]];
+
+  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);
+  }
+  return result;
+};
+
+const write_lsb = (imgData, setdata) => {
+  function unsetbit(k) {
+    return k % 2 == 1 ? k - 1 : k;
+  }
+
+  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;
+};
+
+exports.extractMessageFromImage = async (imagepath, encKey) => {
+  let c, ctx, imgData;
+
+  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];
+  }
+
+  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];
+  } catch (err) {
+    return [
+      false,
+      "Message does not decrypt. Maybe due to (1) wrong password / enc method. (2) corrupted file",
+    ];
+  }
+};
+
+exports.encodeMessageToImage = async (imagepath, msg, encKey) => {
+  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);
+    const encryptedBitStream = prepare_write_data(
+      bitStream,
+      encKey,
+      encode_len
+    );
+
+    const encryptedImgData = write_lsb(imgData, encryptedBitStream);
+    ctx.putImageData(encryptedImgData, 0, 0);
+    const encodedImageBuffer = c.toBuffer("image/png");
+    fs.writeFileSync("encoded.png", encodedImageBuffer);
+
+    return true;
+  } catch (err) {
+    throw err;
+  }
+};

package/bin/utils/utils.js

@@ -0,0 +1,124 @@
+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());
+  const result = [];
+  let loc;
+  const seed = SHA512(password).words.reduce(function (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];
+  }
+  return result;
+};
+
+const utf8Decode = (bytes) => {
+  var chars = [],
+    offset = 0,
+    length = bytes.length,
+    c,
+    c2,
+    c3;
+
+  while (offset < length) {
+    c = bytes[offset];
+    c2 = bytes[offset + 1];
+    c3 = bytes[offset + 2];
+
+    if (128 > c) {
+      chars.push(String.fromCharCode(c));
+      offset += 1;
+    } else if (191 < c && c < 224) {
+      chars.push(String.fromCharCode(((c & 31) << 6) | (c2 & 63)));
+      offset += 2;
+    } else {
+      chars.push(
+        String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63))
+      );
+      offset += 3;
+    }
+  }
+
+  return chars.join("");
+};
+
+const utf8Encode = (str) => {
+  var bytes = [],
+    offset = 0,
+    length,
+    char;
+
+  str = encodeURI(str);
+  length = str.length;
+
+  while (offset < length) {
+    char = str[offset];
+    offset += 1;
+
+    if ("%" !== char) {
+      bytes.push(char.charCodeAt(0));
+    } else {
+      char = str[offset] + str[offset + 1];
+      bytes.push(parseInt(char, 16));
+      offset += 2;
+    }
+  }
+
+  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);
+    }
+    if (data == 255) break; //END NOTATION
+    msg_array.push(data);
+  }
+
+  return utf8Decode(msg_array);
+};
+
+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);
+    }
+  }
+  for (let j = 0; j < 24; j++)
+    for (let i = 0; i < num_copy; i++) {
+      result.push(1);
+    }
+  return result;
+};
+
+module.exports = { get_hashed_order, str_to_bits, bits_to_str };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "obscr",
+  "version": "0.1.1",
+  "description": "Encrypt and hide your secure data",
+  "main": "bin/index.js",
+  "bin": {
+    "obscr": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "author": "Johannes Dragulanescu",
+  "license": "MIT",
+  "repository": "github:jdragulanescu/obscr",
+  "keywords": [
+    "steganography",
+    "security",
+    "encryption",
+    "cryptography",
+    "crypto"
+  ],
+  "dependencies": {
+    "canvas": "^2.9.3",
+    "chalk": "^4.1.2",
+    "crypto-js": "^4.1.1",
+    "inquirer": "^8.0.0",
+    "yargs": "^17.5.1"
+  }
+}