k9crypt 1.0.6 → 1.0.9

package/README.md

@@ -2,6 +2,10 @@
 
 This is a special encryption algorithm created for K9Crypt.
 
+## Updates
+**v1.0.9**
+- Added new compression algorithm and increased compression ratio.
+
 ## Installation
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k9crypt",
-  "version": "1.0.6",
+  "version": "1.0.9",
   "description": "A special encryption algorithm created for K9Crypt.",
   "main": "index.js",
   "scripts": {
@@ -21,10 +21,10 @@
     "bcrypt": "^5.1.1",
     "crypto-js": "^4.2.0",
     "lz4": "^0.6.5",
+    "lzma-native": "^8.0.6",
     "node-forge": "^1.3.1",
     "xxhash": "^0.3.0"
   },
-  "devDependencies": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/K9Crypt/module.git"

package/src/index.js

@@ -15,10 +15,10 @@ class K9crypt {
             const compressed = await compress(plaintext);
             const salt = crypto.randomBytes(SALT_SIZE);
             const key = await deriveKey(this.secretKey, salt);
-            const { iv1, iv2, encrypted, tag1 } = encrypt(compressed, key);
-            const dataToHash = Buffer.concat([salt, iv1, iv2, encrypted, tag1]);
+            const { iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = encrypt(compressed, key);
+            const dataToHash = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1]);
             const dataHash = hash(dataToHash);
-            const result = Buffer.concat([salt, iv1, iv2, encrypted, tag1, dataHash]);
+            const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, dataHash]);
             return result.toString('base64');
         } catch (error) {
             console.log('Encryption failed');
@@ -31,7 +31,10 @@ class K9crypt {
             const salt = data.slice(0, SALT_SIZE);
             const iv1 = data.slice(SALT_SIZE, SALT_SIZE + IV_SIZE);
             const iv2 = data.slice(SALT_SIZE + IV_SIZE, SALT_SIZE + 2 * IV_SIZE);
-            const encrypted = data.slice(SALT_SIZE + 2 * IV_SIZE, -TAG_SIZE - 64);
+            const iv3 = data.slice(SALT_SIZE + 2 * IV_SIZE, SALT_SIZE + 3 * IV_SIZE);
+            const iv4 = data.slice(SALT_SIZE + 3 * IV_SIZE, SALT_SIZE + 4 * IV_SIZE);
+            const iv5 = data.slice(SALT_SIZE + 4 * IV_SIZE, SALT_SIZE + 5 * IV_SIZE);
+            const encrypted = data.slice(SALT_SIZE + 5 * IV_SIZE, -TAG_SIZE - 64);
             const tag1 = data.slice(-TAG_SIZE - 64, -64);
             const dataHash = data.slice(-64);
 
@@ -41,7 +44,7 @@ class K9crypt {
             }
 
             const key = await deriveKey(this.secretKey, salt);
-            const decrypted = decrypt(encrypted, key, iv1, iv2, tag1);
+            const decrypted = decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
             const decompressed = await decompress(decrypted);
             return decompressed.toString('utf8');
         } catch (error) {

package/src/utils/compression.js

@@ -1,19 +1,44 @@
 const zlib = require('zlib');
+const lzma = require('lzma-native');
 
-exports.compress = (data) => {
-    return new Promise((resolve, reject) => {
-        zlib.brotliCompress(Buffer.from(data, 'utf8'), (err, compressed) => {
-            if (err) reject(err);
-            else resolve(compressed);
+exports.compress = async (data) => {
+    try {
+        const brotliParams = {
+            params: {
+                [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
+                [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
+                [zlib.constants.BROTLI_PARAM_SIZE_HINT]: Buffer.byteLength(data, 'utf8'),
+                [zlib.constants.BROTLI_PARAM_LGWIN]: 24
+            }
+        };
+
+        const brotliCompressed = await new Promise((resolve, reject) => {
+            zlib.brotliCompress(Buffer.from(data, 'utf8'), brotliParams, (err, compressed) => {
+                if (err) reject(err);
+                else resolve(compressed);
+            });
         });
-    });
+
+        const lzmaCompressed = await lzma.compress(brotliCompressed, 9);
+        return lzmaCompressed;
+    } catch (error) {
+      throw new Error(`Compression error: ${error.message}`);
+    }
 };
 
-exports.decompress = (data) => {
-    return new Promise((resolve, reject) => {
-        zlib.brotliDecompress(data, (err, decompressed) => {
-            if (err) reject(err);
-            else resolve(decompressed);
+exports.decompress = async (data) => {
+    try {
+        const lzmaDecompressed = await lzma.decompress(data);
+
+        const brotliDecompressed = await new Promise((resolve, reject) => {
+            zlib.brotliDecompress(lzmaDecompressed, (err, decompressed) => {
+                if (err) reject(err);
+                else resolve(decompressed);
+            });
         });
-    });
-};
+
+        return brotliDecompressed;
+    } catch (error) {
+      throw new Error(`Decompression error: ${error.message}`);
+    }
+};

package/src/utils/encryption.js

@@ -12,15 +12,36 @@ exports.encrypt = (data, key) => {
     const cipher2 = crypto.createCipheriv('aes-256-cbc', key, iv2);
     let encrypted2 = cipher2.update(encrypted1);
     encrypted2 = Buffer.concat([encrypted2, cipher2.final()]);
-    const permutedEncrypted = reverseBuffer(encrypted2);
+    const iv3 = crypto.randomBytes(IV_SIZE);
+    const cipher3 = crypto.createCipheriv('aes-256-cfb', key, iv3);
+    let encrypted3 = cipher3.update(encrypted2);
+    encrypted3 = Buffer.concat([encrypted3, cipher3.final()]);
+    const iv4 = crypto.randomBytes(IV_SIZE);
+    const cipher4 = crypto.createCipheriv('aes-256-ofb', key, iv4);
+    let encrypted4 = cipher4.update(encrypted3);
+    encrypted4 = Buffer.concat([encrypted4, cipher4.final()]);
+    const iv5 = crypto.randomBytes(IV_SIZE);
+    const cipher5 = crypto.createCipheriv('aes-256-ctr', key, iv5);
+    let encrypted5 = cipher5.update(encrypted4);
+    encrypted5 = Buffer.concat([encrypted5, cipher5.final()]);
+    const permutedEncrypted = reverseBuffer(encrypted5);
 
-    return { iv1, iv2, encrypted: permutedEncrypted, tag1 };
+    return { iv1, iv2, iv3, iv4, iv5, encrypted: permutedEncrypted, tag1 };
 };
 
-exports.decrypt = (encrypted, key, iv1, iv2, tag1) => {
+exports.decrypt = (encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1) => {
     const originalEncrypted = reverseBuffer(encrypted, true);
+    const decipher5 = crypto.createDecipheriv('aes-256-ctr', key, iv5);
+    let decrypted5 = decipher5.update(originalEncrypted);
+    decrypted5 = Buffer.concat([decrypted5, decipher5.final()]);
+    const decipher4 = crypto.createDecipheriv('aes-256-ofb', key, iv4);
+    let decrypted4 = decipher4.update(decrypted5);
+    decrypted4 = Buffer.concat([decrypted4, decipher4.final()]);
+    const decipher3 = crypto.createDecipheriv('aes-256-cfb', key, iv3);
+    let decrypted3 = decipher3.update(decrypted4);
+    decrypted3 = Buffer.concat([decrypted3, decipher3.final()]);
     const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv2);
-    let decrypted2 = decipher2.update(originalEncrypted);
+    let decrypted2 = decipher2.update(decrypted3);
     decrypted2 = Buffer.concat([decrypted2, decipher2.final()]);
     const decipher1 = crypto.createDecipheriv('aes-256-gcm', key, iv1);
     decipher1.setAuthTag(tag1);
@@ -28,4 +49,4 @@ exports.decrypt = (encrypted, key, iv1, iv2, tag1) => {
     decrypted1 = Buffer.concat([decrypted1, decipher1.final()]);
 
     return decrypted1;
-};
+};