k9crypt 1.1.0 → 1.1.2

package/README.md

@@ -1,10 +1,12 @@
-# K9Crypt Encryption Algorithm
+![](https://www.upload.ee/image/18092921/k9crypt-npm-banner.png)
+
+# K9Crypt Algorithm
 
 This is a special encryption algorithm created for K9Crypt.
 
 ## Updates
-**v1.1.0**
-- Modules have been updated to the latest version.
+**v1.1.2**
+- The issue caused by modules has been resolved.
 
 ## Installation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k9crypt",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "A special encryption algorithm created for K9Crypt.",
   "main": "index.js",
   "scripts": {
@@ -18,12 +18,12 @@
   "author": "K9Crypt Team",
   "license": "MIT",
   "dependencies": {
-    "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"
+    "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

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

package/src/index.js

@@ -6,51 +6,51 @@ const { hash, verifyHash } = require('./utils/hashing');
 const { SALT_SIZE, IV_SIZE, TAG_SIZE } = require('./constants');
 
 class K9crypt {
-    constructor(secretKey) {
-        this.secretKey = secretKey;
-    }
+  constructor(secretKey) {
+    this.secretKey = secretKey;
+  }
 
-    async encrypt(plaintext) {
-        try {
-            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 dataHash = hash(dataToHash);
-            const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, dataHash]);
-            return result.toString('base64');
-        } catch (error) {
-            console.log('Encryption failed');
-        }
+  async encrypt(plaintext) {
+    try {
+      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 dataHash = hash(dataToHash);
+      const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, dataHash]);
+      return result.toString('base64');
+    } catch (error) {
+      console.log('Encryption failed');
     }
+  }
 
-    async decrypt(ciphertext) {
-        try {
-            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);
-            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);
+  async decrypt(ciphertext) {
+    try {
+      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);
+      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);
 
-            const dataToVerify = data.slice(0, -64);
-            if (!verifyHash(dataToVerify, dataHash)) {
-                console.log('Data integrity check failed');
-            }
+      const dataToVerify = data.slice(0, -64);
+      if (!verifyHash(dataToVerify, dataHash)) {
+        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');
-        } catch (error) {
-            console.log('Decryption 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');
+    } catch (error) {
+      console.log('Decryption failed');
     }
+  }
 }
 
 module.exports = K9crypt;

package/src/utils/compression.js

@@ -2,43 +2,43 @@ 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
-            }
-        };
+  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 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}`);
-    }
+    const lzmaCompressed = await lzma.compress(brotliCompressed, 9);
+    return lzmaCompressed;
+  } catch (error) {
+    throw new Error(`Compression error: ${error.message}`);
+  }
 };
 
 exports.decompress = async (data) => {
-    try {
-        const lzmaDecompressed = await lzma.decompress(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);
-            });
-        });
+    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}`);
-    }
-};
+    return brotliDecompressed;
+  } catch (error) {
+    throw new Error(`Decompression error: ${error.message}`);
+  }
+};

package/src/utils/encryption.js

@@ -3,50 +3,50 @@ 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);
-    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);
-    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);
-    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);
+  const iv1 = crypto.randomBytes(IV_SIZE);
+  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);
+  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);
+  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, iv3, iv4, iv5, encrypted: permutedEncrypted, tag1 };
+  return { iv1, iv2, iv3, iv4, iv5, encrypted: permutedEncrypted, 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(decrypted3);
-    decrypted2 = Buffer.concat([decrypted2, decipher2.final()]);
-    const decipher1 = crypto.createDecipheriv('aes-256-gcm', key, iv1);
-    decipher1.setAuthTag(tag1);
-    let decrypted1 = decipher1.update(decrypted2);
-    decrypted1 = Buffer.concat([decrypted1, decipher1.final()]);
+  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(decrypted3);
+  decrypted2 = Buffer.concat([decrypted2, decipher2.final()]);
+  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;
+  return decrypted1;
 };

package/src/utils/hashing.js

@@ -3,11 +3,11 @@ const { HMAC_KEY } = require('../constants');
 const { reverseHash } = require('./math');
 
 exports.hash = (data) => {
-    const hmac = crypto.createHmac('sha512', HMAC_KEY);
-    hmac.update(data);
-    const digest = hmac.digest();
+  const hmac = crypto.createHmac('sha512', HMAC_KEY);
+  hmac.update(data);
+  const digest = hmac.digest();
 
-    return reverseHash(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

@@ -3,14 +3,14 @@ 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);
+  return new Promise((resolve, reject) => {
+    const pepperedPassword = password + PEPPER;
+    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,15 +1,14 @@
 exports.reverseBuffer = (data, reverse = false) => {
-    if (reverse) {
-        return Buffer.from(data.toString('hex').split('').reverse().join(''), 'hex');
-    }
+  if (reverse) {
     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');
 };
-