@kryklin/darkstar-crypt-node 1.0.1 → 1.0.3

package/darkstar_crypt.js

@@ -121,8 +121,8 @@ export class DarkstarCrypt {
       data: encryptedContent,
     };
 
-    const reverseKeyString = JSON.stringify(reverseKey);
-    const encodedReverseKey = btoa(reverseKeyString);
+    // Compress the reverse key using binary packing (4 bits per value)
+    const encodedReverseKey = this.packReverseKey(reverseKey);
 
     return { encryptedData: JSON.stringify(resultObj), reverseKey: encodedReverseKey };
   }
@@ -159,8 +159,19 @@ export class DarkstarCrypt {
     for(let i=0; i<binaryString.length; i++) fullBlob[i] = binaryString.charCodeAt(i);
 
     // Decode Reverse Key
-    const reverseKeyString = atob(reverseKeyB64);
-    const reverseKeyJson = JSON.parse(reverseKeyString);
+    let reverseKeyJson;
+    try {
+      // Try to detect Legacy/V2 JSON key format
+      const reversedKeyString = atob(reverseKeyB64);
+      if (reversedKeyString.trim().startsWith('[')) {
+         reverseKeyJson = JSON.parse(reversedKeyString);
+      } else {
+         reverseKeyJson = this.unpackReverseKey(reverseKeyB64);
+      }
+    } catch (e) {
+      // Fallback
+      reverseKeyJson = this.unpackReverseKey(reverseKeyB64);
+    }
 
     const deobfuscatedWords = [];
     const passwordBytes = this.stringToBytes(password);
@@ -233,7 +244,7 @@ export class DarkstarCrypt {
     const saltHex = this.buf2hex(salt);
     const ivHex = this.buf2hex(iv);
     const ciphertextBase64 = this.buf2base64(encrypted);
-
+    
     return saltHex + ivHex + ciphertextBase64;
   }
 
@@ -297,6 +308,57 @@ export class DarkstarCrypt {
     return btoa(binary);
   }
 
+  // --- Compression Helpers ---
+
+  packReverseKey(reverseKey) {
+    const wordCount = reverseKey.length;
+    // 12 numbers per word, 4 bits each -> 6 bytes
+    const packedSize = wordCount * 6;
+    const buffer = new Uint8Array(packedSize);
+
+    let offset = 0;
+    for (const wordKey of reverseKey) {
+        if (wordKey.length !== 12) throw new Error("Cannot compress non-standard reverse key length.");
+        
+        for (let i = 0; i < 12; i += 2) {
+            const high = wordKey[i]; // 0-11
+            const low = wordKey[i+1]; // 0-11
+            // Pack into one byte
+            buffer[offset++] = (high << 4) | (low & 0x0F);
+        }
+    }
+    return this.buf2base64(buffer);
+  }
+
+  unpackReverseKey(base64) {
+    // Decode base64 to bytes
+    const binary = atob(base64);
+    const buffer = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      buffer[i] = binary.charCodeAt(i);
+    }
+    
+    // Unpack
+    const reverseKey = [];
+    // 6 bytes per word
+    const wordCount = buffer.length / 6;
+
+    let offset = 0;
+    for (let w = 0; w < wordCount; w++) {
+      const wordKey = [];
+      for (let i = 0; i < 6; i++) {
+        const byte = buffer[offset++];
+        const high = (byte >> 4) & 0x0F;
+        const low = byte & 0x0F;
+        wordKey.push(high);
+        wordKey.push(low);
+      }
+      reverseKey.push(wordKey);
+    }
+    
+    return reverseKey;
+  }
+
   stringToBytes(str) {
     return new TextEncoder().encode(str);
   }
@@ -557,3 +619,53 @@ export class DarkstarCrypt {
     };
   }
 }
+
+// --- CLI Support ---
+
+import { fileURLToPath } from 'node:url';
+import { resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const isMain = process.argv[1] && resolve(process.argv[1]) === resolve(__filename);
+
+if (isMain) {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const crypt = new DarkstarCrypt();
+
+    if (command === 'encrypt') {
+        const mnemonic = args[1];
+        const password = args[2];
+        crypt.encrypt(mnemonic, password).then(res => {
+            console.log(JSON.stringify(res));
+        }).catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+    } else if (command === 'decrypt') {
+        const data = args[1];
+        const rk = args[2];
+        const password = args[3];
+        crypt.decrypt(data, rk, password).then(res => {
+            console.log(res);
+        }).catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+    } else if (command === 'test') {
+        const mnemonic = "cat dog fish bird";
+        const password = "MySecre!Password123";
+        crypt.encrypt(mnemonic, password).then(res => {
+            return crypt.decrypt(res.encryptedData, res.reverseKey, password);
+        }).then(decrypted => {
+            if (decrypted === "cat dog fish bird") {
+                console.log("Test Passed!");
+            } else {
+                console.error("Test Failed!");
+                process.exit(1);
+            }
+        });
+    } else {
+        console.log("Usage: node darkstar_crypt.js <encrypt|decrypt|test> ...");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kryklin/darkstar-crypt-node",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Standalone Node.js implementation of Darkstar Encryption",
   "main": "darkstar_crypt.js",
   "type": "module",