obscr 0.1.1 → 0.2.1

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;
 };
 

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "obscr",
-  "version": "0.1.1",
+  "version": "0.2.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"
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "test:unit": "jest test/unit",
+    "test:integration": "jest test/integration"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -23,10 +26,27 @@
     "crypto"
   ],
   "dependencies": {
-    "canvas": "^2.9.3",
+    "boxen": "^5.1.2",
     "chalk": "^4.1.2",
+    "cli-progress": "^3.12.0",
     "crypto-js": "^4.1.1",
     "inquirer": "^8.0.0",
+    "ora": "^5.4.1",
+    "pngjs": "^6.0.0",
     "yargs": "^17.5.1"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coverageDirectory": "coverage",
+    "collectCoverageFrom": [
+      "bin/**/*.js",
+      "!bin/index.js"
+    ],
+    "testMatch": [
+      "**/test/**/*.test.js"
+    ]
   }
-}
+}

package/.github/workflows/publish.yml

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