k9crypt 1.1.1 → 1.1.2

package/README.md

@@ -5,8 +5,8 @@
 This is a special encryption algorithm created for K9Crypt.
 
 ## Updates
-**v1.1.1**
-- Modules have been modified.
+**v1.1.2**
+- The issue caused by modules has been resolved.
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k9crypt",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A special encryption algorithm created for K9Crypt.",
   "main": "index.js",
   "scripts": {
@@ -18,10 +18,12 @@
   "author": "K9Crypt Team",
   "license": "MIT",
   "dependencies": {
-    "bcrypt": "5.1.1",
-    "browserify-zlib": "^0.2.0",
-    "crypto-js": "4.2.0",
-    "pako": "^2.1.0"
+    "bcrypt": "^6.0.0",
+    "crypto-js": "^4.2.0",
+    "lz4": "^0.6.5",
+    "lzma-native": "^8.0.6",
+    "node-forge": "^1.3.1",
+    "xxhash": "^0.3.0"
   },
   "repository": {
     "type": "git",

package/src/constants.js

@@ -4,7 +4,7 @@ module.exports = {
   KEY_SIZE: 32,
   TAG_SIZE: 16,
   PBKDF2_ITERATIONS: 310000,
-  HASH_SEED: 0xcafebabe,
-  PEPPER: "veryLongAndComplexPepperValue123!@#$%^&*()_+[]{}|;:,.<>?",
-  HMAC_KEY: "veryLongAndComplexHMACKeyValue456!@#$%^&*()_+[]{}|;:,.<>?",
-};
+  HASH_SEED: 0xCAFEBABE,
+  PEPPER: 'veryLongAndComplexPepperValue123!@#$%^&*()_+[]{}|;:,.<>?',
+  HMAC_KEY: 'veryLongAndComplexHMACKeyValue456!@#$%^&*()_+[]{}|;:,.<>?',
+};

package/src/index.js

@@ -1,9 +1,9 @@
-const crypto = require("crypto");
-const { compress, decompress } = require("./utils/compression");
-const { deriveKey } = require("./utils/keyDerivation");
-const { encrypt, decrypt } = require("./utils/encryption");
-const { hash, verifyHash } = require("./utils/hashing");
-const { SALT_SIZE, IV_SIZE, TAG_SIZE } = require("./constants");
+const crypto = require('crypto');
+const { compress, decompress } = require('./utils/compression');
+const { deriveKey } = require('./utils/keyDerivation');
+const { encrypt, decrypt } = require('./utils/encryption');
+const { hash, verifyHash } = require('./utils/hashing');
+const { SALT_SIZE, IV_SIZE, TAG_SIZE } = require('./constants');
 
 class K9crypt {
   constructor(secretKey) {
@@ -15,41 +15,19 @@ class K9crypt {
       const compressed = await compress(plaintext);
       const salt = crypto.randomBytes(SALT_SIZE);
       const key = await deriveKey(this.secretKey, salt);
-      const { iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = encrypt(
-        compressed,
-        key,
-      );
-      const dataToHash = Buffer.concat([
-        salt,
-        iv1,
-        iv2,
-        iv3,
-        iv4,
-        iv5,
-        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,
-        iv3,
-        iv4,
-        iv5,
-        encrypted,
-        tag1,
-        dataHash,
-      ]);
-      return result.toString("base64");
+      const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, dataHash]);
+      return result.toString('base64');
     } catch (error) {
-      console.log("Encryption failed");
+      console.log('Encryption failed');
     }
   }
 
   async decrypt(ciphertext) {
     try {
-      const data = Buffer.from(ciphertext, "base64");
+      const data = Buffer.from(ciphertext, 'base64');
       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);
@@ -62,17 +40,17 @@ class K9crypt {
 
       const dataToVerify = data.slice(0, -64);
       if (!verifyHash(dataToVerify, dataHash)) {
-        console.log("Data integrity check failed");
+        console.log('Data integrity check failed');
       }
 
       const key = await deriveKey(this.secretKey, salt);
       const decrypted = decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
       const decompressed = await decompress(decrypted);
-      return decompressed.toString("utf8");
+      return decompressed.toString('utf8');
     } catch (error) {
-      console.log("Decryption failed");
+      console.log('Decryption failed');
     }
   }
 }
 
-module.exports = K9crypt;
+module.exports = K9crypt;

package/src/utils/compression.js

@@ -1,35 +1,26 @@
-const zlib = require("browserify-zlib");
-const pako = require("pako");
+const zlib = require('zlib');
+const lzma = require('lzma-native');
 
 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,
-      },
+        [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);
-        },
-      );
+      zlib.brotliCompress(Buffer.from(data, 'utf8'), brotliParams, (err, compressed) => {
+        if (err) reject(err);
+        else resolve(compressed);
+      });
     });
-    const pakoCompressed = Buffer.from(
-      pako.deflate(brotliCompressed, { level: 9 }),
-    );
-    return pakoCompressed;
+
+    const lzmaCompressed = await lzma.compress(brotliCompressed, 9);
+    return lzmaCompressed;
   } catch (error) {
     throw new Error(`Compression error: ${error.message}`);
   }
@@ -37,10 +28,10 @@ exports.compress = async (data) => {
 
 exports.decompress = async (data) => {
   try {
-    const pakoDecompressed = Buffer.from(pako.inflate(data));
+    const lzmaDecompressed = await lzma.decompress(data);
 
     const brotliDecompressed = await new Promise((resolve, reject) => {
-      zlib.brotliDecompress(pakoDecompressed, (err, decompressed) => {
+      zlib.brotliDecompress(lzmaDecompressed, (err, decompressed) => {
         if (err) reject(err);
         else resolve(decompressed);
       });
@@ -50,4 +41,4 @@ exports.decompress = async (data) => {
   } catch (error) {
     throw new Error(`Decompression error: ${error.message}`);
   }
-};
+};

package/src/utils/encryption.js

@@ -1,27 +1,27 @@
-const crypto = require("crypto");
-const { IV_SIZE } = require("../constants");
-const { reverseBuffer } = require("./math");
+const crypto = require('crypto');
+const { IV_SIZE } = require('../constants');
+const { reverseBuffer } = require('./math');
 
 exports.encrypt = (data, key) => {
   const iv1 = crypto.randomBytes(IV_SIZE);
-  const cipher1 = crypto.createCipheriv("aes-256-gcm", key, iv1);
+  const cipher1 = crypto.createCipheriv('aes-256-gcm', key, iv1);
   let encrypted1 = cipher1.update(data);
   encrypted1 = Buffer.concat([encrypted1, cipher1.final()]);
   const tag1 = cipher1.getAuthTag();
   const iv2 = crypto.randomBytes(IV_SIZE);
-  const cipher2 = crypto.createCipheriv("aes-256-cbc", key, iv2);
+  const cipher2 = crypto.createCipheriv('aes-256-cbc', key, iv2);
   let encrypted2 = cipher2.update(encrypted1);
   encrypted2 = Buffer.concat([encrypted2, cipher2.final()]);
   const iv3 = crypto.randomBytes(IV_SIZE);
-  const cipher3 = crypto.createCipheriv("aes-256-cfb", key, iv3);
+  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);
+  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);
+  const cipher5 = crypto.createCipheriv('aes-256-ctr', key, iv5);
   let encrypted5 = cipher5.update(encrypted4);
   encrypted5 = Buffer.concat([encrypted5, cipher5.final()]);
   const permutedEncrypted = reverseBuffer(encrypted5);
@@ -31,22 +31,22 @@ exports.encrypt = (data, key) => {
 
 exports.decrypt = (encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1) => {
   const originalEncrypted = reverseBuffer(encrypted, true);
-  const decipher5 = crypto.createDecipheriv("aes-256-ctr", key, iv5);
+  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);
+  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);
+  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);
+  const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv2);
   let decrypted2 = decipher2.update(decrypted3);
   decrypted2 = Buffer.concat([decrypted2, decipher2.final()]);
-  const decipher1 = crypto.createDecipheriv("aes-256-gcm", key, iv1);
+  const decipher1 = crypto.createDecipheriv('aes-256-gcm', key, iv1);
   decipher1.setAuthTag(tag1);
   let decrypted1 = decipher1.update(decrypted2);
   decrypted1 = Buffer.concat([decrypted1, decipher1.final()]);
 
   return decrypted1;
-};
+};

package/src/utils/hashing.js

@@ -1,14 +1,13 @@
-const crypto = require("crypto");
-const { HMAC_KEY } = require("../constants");
-const { reverseHash } = require("./math");
+const crypto = require('crypto');
+const { HMAC_KEY } = require('../constants');
+const { reverseHash } = require('./math');
 
 exports.hash = (data) => {
-  const hmac = crypto.createHmac("sha512", HMAC_KEY);
+  const hmac = crypto.createHmac('sha512', HMAC_KEY);
   hmac.update(data);
   const digest = hmac.digest();
 
   return reverseHash(digest);
 };
 
-exports.verifyHash = (data, hash) =>
-  crypto.timingSafeEqual(exports.hash(data), hash);
+exports.verifyHash = (data, hash) => crypto.timingSafeEqual(exports.hash(data), hash);

package/src/utils/keyDerivation.js

@@ -1,23 +1,16 @@
-const crypto = require("crypto");
-const { PBKDF2_ITERATIONS, KEY_SIZE, PEPPER } = require("../constants");
-const { enhanceKey } = require("./math");
+const crypto = require('crypto');
+const { PBKDF2_ITERATIONS, KEY_SIZE, PEPPER } = require('../constants');
+const { enhanceKey } = require('./math');
 
 exports.deriveKey = (password, salt) => {
   return new Promise((resolve, reject) => {
     const pepperedPassword = password + PEPPER;
-    crypto.pbkdf2(
-      pepperedPassword,
-      salt,
-      PBKDF2_ITERATIONS,
-      KEY_SIZE,
-      "sha512",
-      (err, key) => {
-        if (err) reject(err);
+    crypto.pbkdf2(pepperedPassword, salt, PBKDF2_ITERATIONS, KEY_SIZE, 'sha512', (err, key) => {
+      if (err) reject(err);
 
-        const enhancedKey = enhanceKey(key);
+      const enhancedKey = enhanceKey(key);
 
-        resolve(enhancedKey);
-      },
-    );
+      resolve(enhancedKey);
+    });
   });
-};
+};

package/src/utils/math.js

@@ -1,17 +1,14 @@
 exports.reverseBuffer = (data, reverse = false) => {
   if (reverse) {
-    return Buffer.from(
-      data.toString("hex").split("").reverse().join(""),
-      "hex",
-    );
+    return Buffer.from(data.toString('hex').split('').reverse().join(''), 'hex');
   }
-  return Buffer.from(data.toString("hex").split("").reverse().join(""), "hex");
+  return Buffer.from(data.toString('hex').split('').reverse().join(''), 'hex');
 };
 
 exports.reverseHash = (hash) => {
-  return Buffer.from(hash.toString("hex").split("").reverse().join(""), "hex");
+  return Buffer.from(hash.toString('hex').split('').reverse().join(''), 'hex');
 };
 
 exports.enhanceKey = (key) => {
-  return Buffer.from(key.toString("hex").split("").reverse().join(""), "hex");
+  return Buffer.from(key.toString('hex').split('').reverse().join(''), 'hex');
 };