k9crypt 1.1.6 → 1.1.8

package/README.md

@@ -6,9 +6,13 @@ This is a special encryption algorithm created for K9Crypt.
 
 ## Updates
 
-**v1.1.6**
+**v1.1.8**
 
-- Due to issues reported in feedback, it has been updated to be usable only as CommonJS.
+- Added `encryptFile()` and `decryptFile()` methods for large file encryption with progress tracking
+- Added `encryptMany()` and `decryptMany()` methods for batch operations with sequential and parallel processing
+- Introduced compression level control (0-9) for flexible speed/size balance
+- All method names simplified for better user experience
+- Parallel processing support for high-volume data operations
 
 ## Installation
 
@@ -21,6 +25,8 @@ bun add k9crypt
 
 ## Usage
 
+### Basic Usage
+
 ```javascript
 const k9crypt = require('k9crypt');
 
@@ -45,6 +51,85 @@ async function test() {
 test();
 ```
 
+### Advanced Features
+
+#### Compression Level Control
+
+```javascript
+const encryptor = new k9crypt(secretKey, { compressionLevel: 5 });
+
+const encrypted = await encryptor.encrypt(plaintext, { compressionLevel: 7 });
+```
+
+#### File Encryption with Progress Tracking
+
+```javascript
+async function encryptBigFile() {
+  const largeData = 'Very large data...';
+  
+  const encrypted = await encryptor.encryptFile(largeData, {
+    compressionLevel: 6,
+    onProgress: (progress) => {
+      console.log(`Processed: ${progress.processedBytes} bytes`);
+    }
+  });
+
+  const decrypted = await encryptor.decryptFile(encrypted, {
+    onProgress: (progress) => {
+      console.log(`Decrypted: ${progress.processedBytes} bytes`);
+    }
+  });
+
+  return decrypted;
+}
+```
+
+#### Multiple Data Encryption
+
+```javascript
+async function encryptMultipleData() {
+  const dataArray = ['data1', 'data2', 'data3', 'data4'];
+  
+  const encrypted = await encryptor.encryptMany(dataArray, {
+    compressionLevel: 5,
+    onProgress: (progress) => {
+      console.log(`Progress: ${progress.percentage}% (${progress.current}/${progress.total})`);
+    }
+  });
+
+  const decrypted = await encryptor.decryptMany(encrypted, {
+    skipInvalid: true,
+    onProgress: (progress) => {
+      console.log(`Progress: ${progress.percentage}%`);
+    }
+  });
+
+  return decrypted;
+}
+```
+
+#### Parallel Processing
+
+```javascript
+async function encryptManyDataFast() {
+  const dataArray = Array(100).fill('sample data');
+  
+  const encrypted = await encryptor.encryptMany(dataArray, {
+    parallel: true,
+    batchSize: 20,
+    compressionLevel: 4
+  });
+
+  const decrypted = await encryptor.decryptMany(encrypted, {
+    parallel: true,
+    batchSize: 20,
+    skipInvalid: false
+  });
+
+  return decrypted;
+}
+```
+
 ## License
 
 This project is licensed under the MIT license.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "k9crypt",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "A special encryption algorithm created for K9Crypt.",
   "main": "index.js",
   "scripts": {
@@ -18,12 +18,9 @@
   "author": "K9Crypt Team",
   "license": "MIT",
   "dependencies": {
-    "bcrypt": "^6.0.0",
+    "argon2": "^0.44.0",
     "crypto-js": "^4.2.0",
-    "lz4": "^0.6.5",
-    "lzma-native": "^8.0.6",
-    "node-forge": "^1.3.1",
-    "xxhash": "^0.3.0"
+    "lzma-native": "^8.0.6"
   },
   "repository": {
     "type": "git",

package/src/constants.js

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

package/src/index.js

@@ -3,35 +3,44 @@ 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 { encryptFile, decryptFile } = require('./utils/streamCrypto');
+const { encryptMany, decryptMany, encryptManyParallel, decryptManyParallel } = require('./utils/batchOperations');
+const { SALT_SIZE, IV_SIZE, TAG_SIZE, ARGON2_SALT_SIZE, ARGON2_HASH_LENGTH } = require('./constants');
 
 class K9crypt {
-  constructor(secretKey) {
+  constructor(secretKey, options = {}) {
     if (!secretKey) {
       this.secretKey = crypto.randomBytes(50);
       this._autoGenerated = true;
-    } else {
+    }
+
+    if (secretKey) {
       this._autoGenerated = false;
       this.secretKey = secretKey;
     }
+
+    this.defaultCompressionLevel = options.compressionLevel || 3;
   }
 
   getGenerated() {
     return this._autoGenerated ? this.secretKey : null;
   }
 
-  async encrypt(plaintext) {
+  async encrypt(plaintext, options = {}) {
     try {
-      const compressed = await compress(plaintext);
+      const compressionLevel = options.compressionLevel || this.defaultCompressionLevel;
+      const compressed = await compress(plaintext, compressionLevel);
       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 { iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = await 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]);
+      const argon2Salt = crypto.randomBytes(ARGON2_SALT_SIZE);
+      const dataHash = await hash(dataToHash, argon2Salt);
+      const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, argon2Salt, dataHash]);
+
       return result.toString('base64');
     } catch (error) {
-      console.log('Encryption failed');
+      throw new Error(`Encryption failed: ${error.message}`);
     }
   }
 
@@ -44,21 +53,97 @@ class K9crypt {
       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 dataHash = data.slice(-ARGON2_HASH_LENGTH);
+      const argon2Salt = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE, -ARGON2_HASH_LENGTH);
+      const tag1 = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+      const encrypted = data.slice(SALT_SIZE + 5 * IV_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE);
+
+      const dataToVerify = data.slice(0, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+
+      if (!(await verifyHash(dataToVerify, dataHash, argon2Salt))) {
+        throw new Error('Data integrity check failed');
       }
 
       const key = await deriveKey(this.secretKey, salt);
-      const decrypted = decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
+      const decrypted = await decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
       const decompressed = await decompress(decrypted);
+
       return decompressed.toString('utf8');
     } catch (error) {
-      console.log('Decryption failed');
+      throw new Error(`Decryption failed: ${error.message}`);
+    }
+  }
+
+  async encryptFile(plaintext, options = {}) {
+    try {
+      const compressionLevel = options.compressionLevel || this.defaultCompressionLevel;
+      const onProgress = options.onProgress || null;
+
+      return await encryptFile(plaintext, this.secretKey, {
+        compressionLevel,
+        onProgress
+      });
+    } catch (error) {
+      throw new Error(`File encryption failed: ${error.message}`);
+    }
+  }
+
+  async decryptFile(ciphertext, options = {}) {
+    try {
+      const onProgress = options.onProgress || null;
+
+      return await decryptFile(ciphertext, this.secretKey, {
+        onProgress
+      });
+    } catch (error) {
+      throw new Error(`File decryption failed: ${error.message}`);
+    }
+  }
+
+  async encryptMany(dataArray, options = {}) {
+    try {
+      const compressionLevel = options.compressionLevel || this.defaultCompressionLevel;
+      const onProgress = options.onProgress || null;
+      const parallel = options.parallel || false;
+      const batchSize = options.batchSize || 10;
+
+      if (parallel) {
+        return await encryptManyParallel(dataArray, this.secretKey, {
+          compressionLevel,
+          batchSize
+        });
+      }
+
+      return await encryptMany(dataArray, this.secretKey, {
+        compressionLevel,
+        onProgress
+      });
+    } catch (error) {
+      throw new Error(`Multiple encryption failed: ${error.message}`);
+    }
+  }
+
+  async decryptMany(ciphertextArray, options = {}) {
+    try {
+      const onProgress = options.onProgress || null;
+      const skipInvalid = options.skipInvalid || false;
+      const parallel = options.parallel || false;
+      const batchSize = options.batchSize || 10;
+
+      if (parallel) {
+        return await decryptManyParallel(ciphertextArray, this.secretKey, {
+          skipInvalid,
+          batchSize
+        });
+      }
+
+      return await decryptMany(ciphertextArray, this.secretKey, {
+        skipInvalid,
+        onProgress
+      });
+    } catch (error) {
+      throw new Error(`Multiple decryption failed: ${error.message}`);
     }
   }
 }

package/src/utils/batchOperations.js

@@ -0,0 +1,265 @@
+const crypto = require('crypto');
+const { compress, decompress } = require('./compression');
+const { deriveKey } = require('./keyDerivation');
+const { encrypt, decrypt } = require('./encryption');
+const { hash, verifyHash } = require('./hashing');
+const { SALT_SIZE, IV_SIZE, TAG_SIZE, ARGON2_SALT_SIZE, ARGON2_HASH_LENGTH } = require('../constants');
+
+exports.encryptMany = async (dataArray, secretKey, options = {}) => {
+  try {
+    if (!Array.isArray(dataArray)) {
+      throw new Error('Data must be an array');
+    }
+
+    if (dataArray.length === 0) {
+      return [];
+    }
+
+    const compressionLevel = options.compressionLevel || 3;
+    const onProgress = options.onProgress || null;
+    const results = [];
+    const totalItems = dataArray.length;
+
+    for (let i = 0; i < dataArray.length; i++) {
+      const item = dataArray[i];
+
+      if (item === null || item === undefined) {
+        results.push(null);
+        continue;
+      }
+
+      const compressed = await compress(item, compressionLevel);
+      const salt = crypto.randomBytes(SALT_SIZE);
+      const key = await deriveKey(secretKey, salt);
+      const { iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = await encrypt(compressed, key);
+
+      const dataToHash = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1]);
+      const argon2Salt = crypto.randomBytes(ARGON2_SALT_SIZE);
+      const dataHash = await hash(dataToHash, argon2Salt);
+
+      const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, argon2Salt, dataHash]);
+      results.push(result.toString('base64'));
+
+      if (onProgress) {
+        onProgress({
+          current: i + 1,
+          total: totalItems,
+          percentage: Math.round(((i + 1) / totalItems) * 100)
+        });
+      }
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Batch encryption failed: ${error.message}`);
+  }
+};
+
+exports.decryptMany = async (ciphertextArray, secretKey, options = {}) => {
+  try {
+    if (!Array.isArray(ciphertextArray)) {
+      throw new Error('Data must be an array');
+    }
+
+    if (ciphertextArray.length === 0) {
+      return [];
+    }
+
+    const onProgress = options.onProgress || null;
+    const skipInvalid = options.skipInvalid || false;
+    const results = [];
+    const totalItems = ciphertextArray.length;
+
+    for (let i = 0; i < ciphertextArray.length; i++) {
+      const item = ciphertextArray[i];
+
+      if (item === null || item === undefined) {
+        results.push(null);
+        continue;
+      }
+
+      try {
+        const data = Buffer.from(item, '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 dataHash = data.slice(-ARGON2_HASH_LENGTH);
+        const argon2Salt = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE, -ARGON2_HASH_LENGTH);
+        const tag1 = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+        const encrypted = data.slice(SALT_SIZE + 5 * IV_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE);
+
+        const dataToVerify = data.slice(0, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+
+        if (!(await verifyHash(dataToVerify, dataHash, argon2Salt))) {
+          if (skipInvalid) {
+            results.push(null);
+            continue;
+          }
+
+          throw new Error(`Data integrity check failed for item ${i}`);
+        }
+
+        const key = await deriveKey(secretKey, salt);
+        const decrypted = await decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
+        const decompressed = await decompress(decrypted);
+        results.push(decompressed.toString('utf8'));
+      } catch (error) {
+        if (skipInvalid) {
+          results.push(null);
+        }
+
+        if (!skipInvalid) {
+          throw error;
+        }
+      }
+
+      if (onProgress) {
+        onProgress({
+          current: i + 1,
+          total: totalItems,
+          percentage: Math.round(((i + 1) / totalItems) * 100)
+        });
+      }
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Batch decryption failed: ${error.message}`);
+  }
+};
+
+exports.encryptManyParallel = async (dataArray, secretKey, options = {}) => {
+  try {
+    if (!Array.isArray(dataArray)) {
+      throw new Error('Data must be an array');
+    }
+
+    if (dataArray.length === 0) {
+      return [];
+    }
+
+    const compressionLevel = options.compressionLevel || 3;
+    const batchSize = options.batchSize || 10;
+    const results = new Array(dataArray.length);
+    const batches = [];
+
+    for (let i = 0; i < dataArray.length; i += batchSize) {
+      const batch = dataArray.slice(i, Math.min(i + batchSize, dataArray.length));
+      const batchPromises = batch.map(async (item, index) => {
+        const actualIndex = i + index;
+
+        if (item === null || item === undefined) {
+          return { index: actualIndex, result: null };
+        }
+
+        const compressed = await compress(item, compressionLevel);
+        const salt = crypto.randomBytes(SALT_SIZE);
+        const key = await deriveKey(secretKey, salt);
+        const { iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = await encrypt(compressed, key);
+
+        const dataToHash = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1]);
+        const argon2Salt = crypto.randomBytes(ARGON2_SALT_SIZE);
+        const dataHash = await hash(dataToHash, argon2Salt);
+
+        const result = Buffer.concat([salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1, argon2Salt, dataHash]);
+        return { index: actualIndex, result: result.toString('base64') };
+      });
+
+      batches.push(Promise.all(batchPromises));
+    }
+
+    const batchResults = await Promise.all(batches);
+
+    for (const batch of batchResults) {
+      for (const item of batch) {
+        results[item.index] = item.result;
+      }
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Parallel batch encryption failed: ${error.message}`);
+  }
+};
+
+exports.decryptManyParallel = async (ciphertextArray, secretKey, options = {}) => {
+  try {
+    if (!Array.isArray(ciphertextArray)) {
+      throw new Error('Data must be an array');
+    }
+
+    if (ciphertextArray.length === 0) {
+      return [];
+    }
+
+    const batchSize = options.batchSize || 10;
+    const skipInvalid = options.skipInvalid || false;
+    const results = new Array(ciphertextArray.length);
+    const batches = [];
+
+    for (let i = 0; i < ciphertextArray.length; i += batchSize) {
+      const batch = ciphertextArray.slice(i, Math.min(i + batchSize, ciphertextArray.length));
+      const batchPromises = batch.map(async (item, index) => {
+        const actualIndex = i + index;
+
+        if (item === null || item === undefined) {
+          return { index: actualIndex, result: null };
+        }
+
+        try {
+          const data = Buffer.from(item, '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 dataHash = data.slice(-ARGON2_HASH_LENGTH);
+          const argon2Salt = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE, -ARGON2_HASH_LENGTH);
+          const tag1 = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+          const encrypted = data.slice(SALT_SIZE + 5 * IV_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE);
+
+          const dataToVerify = data.slice(0, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+
+          if (!(await verifyHash(dataToVerify, dataHash, argon2Salt))) {
+            if (skipInvalid) {
+              return { index: actualIndex, result: null };
+            }
+
+            throw new Error(`Data integrity check failed for item ${actualIndex}`);
+          }
+
+          const key = await deriveKey(secretKey, salt);
+          const decrypted = await decrypt(encrypted, key, iv1, iv2, iv3, iv4, iv5, tag1);
+          const decompressed = await decompress(decrypted);
+          return { index: actualIndex, result: decompressed.toString('utf8') };
+        } catch (error) {
+          if (skipInvalid) {
+            return { index: actualIndex, result: null };
+          }
+
+          throw error;
+        }
+      });
+
+      batches.push(Promise.all(batchPromises));
+    }
+
+    const batchResults = await Promise.all(batches);
+
+    for (const batch of batchResults) {
+      for (const item of batch) {
+        results[item.index] = item.result;
+      }
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Parallel batch decryption failed: ${error.message}`);
+  }
+};

package/src/utils/compression.js

@@ -1,25 +1,36 @@
 const zlib = require('zlib');
 const lzma = require('lzma-native');
 
-exports.compress = async (data) => {
+exports.compress = async (data, compressionLevel = 3) => {
   try {
+    if (compressionLevel < 0 || compressionLevel > 9) {
+      throw new Error('Compression level must be between 0 and 9');
+    }
+
+    const brotliQuality = Math.min(Math.max(Math.floor(compressionLevel / 2), 1), 11);
+    const lzmaLevel = Math.min(compressionLevel, 9);
+
     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_QUALITY]: brotliQuality,
         [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);
+          if (!err) resolve(compressed);
+        }
+      );
     });
 
-    const lzmaCompressed = await lzma.compress(brotliCompressed, 9);
+    const lzmaCompressed = await lzma.compress(brotliCompressed, lzmaLevel);
     return lzmaCompressed;
   } catch (error) {
     throw new Error(`Compression error: ${error.message}`);
@@ -41,4 +52,4 @@ exports.decompress = async (data) => {
   } catch (error) {
     throw new Error(`Decompression error: ${error.message}`);
   }
-};
+};

package/src/utils/encryption.js

@@ -1,52 +1,61 @@
 const crypto = require('crypto');
+const { Readable } = require('stream');
 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);
-
-  return { iv1, iv2, iv3, iv4, iv5, encrypted: permutedEncrypted, tag1 };
+  return new Promise((resolve, reject) => {
+    const iv1 = crypto.randomBytes(IV_SIZE);
+    const cipher1 = crypto.createCipheriv('aes-256-gcm', key, iv1);
+
+    const iv2 = crypto.randomBytes(IV_SIZE);
+    const cipher2 = crypto.createCipheriv('aes-256-cbc', key, iv2);
+
+    const iv3 = crypto.randomBytes(IV_SIZE);
+    const cipher3 = crypto.createCipheriv('aes-256-cfb', key, iv3);
+
+    const iv4 = crypto.randomBytes(IV_SIZE);
+    const cipher4 = crypto.createCipheriv('aes-256-ofb', key, iv4);
+
+    const iv5 = crypto.randomBytes(IV_SIZE);
+    const cipher5 = crypto.createCipheriv('aes-256-ctr', key, iv5);
+
+    const readable = Readable.from(data);
+    const chunks = [];
+
+    const stream = readable.pipe(cipher1).pipe(cipher2).pipe(cipher3).pipe(cipher4).pipe(cipher5);
+
+    stream.on('data', (chunk) => chunks.push(chunk));
+    stream.on('error', (err) => reject(err));
+    stream.on('end', () => {
+      const encrypted = Buffer.concat(chunks);
+      const tag1 = cipher1.getAuthTag();
+      const permutedEncrypted = reverseBuffer(encrypted);
+      resolve({ 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()]);
-
-  return decrypted1;
+  return new Promise((resolve, reject) => {
+    const originalEncrypted = reverseBuffer(encrypted);
+
+    const decipher5 = crypto.createDecipheriv('aes-256-ctr', key, iv5);
+    const decipher4 = crypto.createDecipheriv('aes-256-ofb', key, iv4);
+    const decipher3 = crypto.createDecipheriv('aes-256-cfb', key, iv3);
+    const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv2);
+    const decipher1 = crypto.createDecipheriv('aes-256-gcm', key, iv1);
+    decipher1.setAuthTag(tag1);
+
+    const readable = Readable.from(originalEncrypted);
+    const chunks = [];
+
+    const stream = readable.pipe(decipher5).pipe(decipher4).pipe(decipher3).pipe(decipher2).pipe(decipher1);
+
+    stream.on('data', (chunk) => chunks.push(chunk));
+    stream.on('error', (err) => reject(err));
+    stream.on('end', () => {
+      resolve(Buffer.concat(chunks));
+    });
+  });
 };

package/src/utils/hashing.js

@@ -1,13 +1,42 @@
 const crypto = require('crypto');
-const { HMAC_KEY } = require('../constants');
+const argon2 = require('argon2');
+const { HMAC_KEY, ARGON2_HASH_LENGTH } = require('../constants');
 const { reverseHash } = require('./math');
 
-exports.hash = (data) => {
+const ARGON2_OPTIONS = {
+  timeCost: 1,
+  memoryCost: 12288,
+  parallelism: 4,
+  type: argon2.argon2id,
+  hashLength: ARGON2_HASH_LENGTH
+};
+
+exports.hash = async (data, salt) => {
   const hmac = crypto.createHmac('sha512', HMAC_KEY);
   hmac.update(data);
   const digest = hmac.digest();
+  const reversedSha512Hash = reverseHash(digest);
+
+  const argon2Hash = await argon2.hash(reversedSha512Hash, {
+    ...ARGON2_OPTIONS,
+    salt,
+    raw: true
+  });
 
-  return reverseHash(digest);
+  return argon2Hash;
 };
 
-exports.verifyHash = (data, hash) => crypto.timingSafeEqual(exports.hash(data), hash);
+exports.verifyHash = async (data, hash, salt) => {
+  const hmac = crypto.createHmac('sha512', HMAC_KEY);
+  hmac.update(data);
+  const digest = hmac.digest();
+  const reversedSha512Hash = reverseHash(digest);
+
+  const expectedHash = await argon2.hash(reversedSha512Hash, {
+    ...ARGON2_OPTIONS,
+    salt,
+    raw: true
+  });
+
+  return crypto.timingSafeEqual(hash, expectedHash);
+};

package/src/utils/math.js

@@ -1,14 +1,11 @@
-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');
+exports.reverseBuffer = (data) => {
+  return Buffer.from(data).reverse();
 };
 
 exports.reverseHash = (hash) => {
-  return Buffer.from(hash.toString('hex').split('').reverse().join(''), 'hex');
+  return Buffer.from(hash).reverse();
 };
 
 exports.enhanceKey = (key) => {
-  return Buffer.from(key.toString('hex').split('').reverse().join(''), 'hex');
-};
+  return Buffer.from(key).reverse();
+};

package/src/utils/streamCrypto.js

@@ -0,0 +1,219 @@
+const crypto = require('crypto');
+const { Readable, Transform, pipeline } = require('stream');
+const { compress, decompress } = require('./compression');
+const { deriveKey } = require('./keyDerivation');
+const { hash, verifyHash } = require('./hashing');
+const { reverseBuffer } = require('./math');
+const { SALT_SIZE, IV_SIZE, TAG_SIZE, ARGON2_SALT_SIZE, ARGON2_HASH_LENGTH } = require('../constants');
+
+const CHUNK_SIZE = 64 * 1024;
+
+exports.encryptStream = async (inputStream, secretKey, onProgress) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const salt = crypto.randomBytes(SALT_SIZE);
+      const key = await deriveKey(secretKey, salt);
+      const iv1 = crypto.randomBytes(IV_SIZE);
+      const iv2 = crypto.randomBytes(IV_SIZE);
+      const iv3 = crypto.randomBytes(IV_SIZE);
+      const iv4 = crypto.randomBytes(IV_SIZE);
+      const iv5 = crypto.randomBytes(IV_SIZE);
+
+      const cipher1 = crypto.createCipheriv('aes-256-gcm', key, iv1);
+      const cipher2 = crypto.createCipheriv('aes-256-cbc', key, iv2);
+      const cipher3 = crypto.createCipheriv('aes-256-cfb', key, iv3);
+      const cipher4 = crypto.createCipheriv('aes-256-ofb', key, iv4);
+      const cipher5 = crypto.createCipheriv('aes-256-ctr', key, iv5);
+
+      const chunks = [];
+      let totalBytes = 0;
+
+      const progressTransform = new Transform({
+        transform(chunk, encoding, callback) {
+          totalBytes += chunk.length;
+
+          if (onProgress) {
+            onProgress({ processedBytes: totalBytes });
+          }
+
+          this.push(chunk);
+          callback();
+        }
+      });
+
+      const encryptionPipeline = pipeline(
+        inputStream,
+        cipher1,
+        cipher2,
+        cipher3,
+        cipher4,
+        cipher5,
+        progressTransform,
+        (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          const encrypted = Buffer.concat(chunks);
+          const tag1 = cipher1.getAuthTag();
+          const permutedEncrypted = reverseBuffer(encrypted);
+
+          resolve({
+            salt,
+            iv1,
+            iv2,
+            iv3,
+            iv4,
+            iv5,
+            encrypted: permutedEncrypted,
+            tag1
+          });
+        }
+      );
+
+      encryptionPipeline.on('data', (chunk) => {
+        chunks.push(chunk);
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+exports.decryptStream = async (encryptedData, secretKey, onProgress) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const { salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1 } = encryptedData;
+      const key = await deriveKey(secretKey, salt);
+      const originalEncrypted = reverseBuffer(encrypted);
+
+      const decipher5 = crypto.createDecipheriv('aes-256-ctr', key, iv5);
+      const decipher4 = crypto.createDecipheriv('aes-256-ofb', key, iv4);
+      const decipher3 = crypto.createDecipheriv('aes-256-cfb', key, iv3);
+      const decipher2 = crypto.createDecipheriv('aes-256-cbc', key, iv2);
+      const decipher1 = crypto.createDecipheriv('aes-256-gcm', key, iv1);
+      decipher1.setAuthTag(tag1);
+
+      const readable = Readable.from(originalEncrypted);
+      const chunks = [];
+      let totalBytes = 0;
+
+      const progressTransform = new Transform({
+        transform(chunk, encoding, callback) {
+          totalBytes += chunk.length;
+
+          if (onProgress) {
+            onProgress({ processedBytes: totalBytes });
+          }
+
+          this.push(chunk);
+          callback();
+        }
+      });
+
+      const decryptionPipeline = pipeline(
+        readable,
+        decipher5,
+        decipher4,
+        decipher3,
+        decipher2,
+        decipher1,
+        progressTransform,
+        (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+
+          resolve(Buffer.concat(chunks));
+        }
+      );
+
+      decryptionPipeline.on('data', (chunk) => {
+        chunks.push(chunk);
+      });
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+exports.encryptFile = async (data, secretKey, options = {}) => {
+  try {
+    const onProgress = options.onProgress || null;
+    const compressionLevel = options.compressionLevel || 3;
+
+    if (!Buffer.isBuffer(data)) {
+      data = Buffer.from(data, 'utf8');
+    }
+
+    const compressed = await compress(data, compressionLevel);
+    const inputStream = Readable.from(compressed);
+
+    const encryptionResult = await exports.encryptStream(inputStream, secretKey, onProgress);
+    const dataToHash = Buffer.concat([
+      encryptionResult.salt,
+      encryptionResult.iv1,
+      encryptionResult.iv2,
+      encryptionResult.iv3,
+      encryptionResult.iv4,
+      encryptionResult.iv5,
+      encryptionResult.encrypted,
+      encryptionResult.tag1
+    ]);
+
+    const argon2Salt = crypto.randomBytes(ARGON2_SALT_SIZE);
+    const dataHash = await hash(dataToHash, argon2Salt);
+
+    const result = Buffer.concat([
+      encryptionResult.salt,
+      encryptionResult.iv1,
+      encryptionResult.iv2,
+      encryptionResult.iv3,
+      encryptionResult.iv4,
+      encryptionResult.iv5,
+      encryptionResult.encrypted,
+      encryptionResult.tag1,
+      argon2Salt,
+      dataHash
+    ]);
+
+    return result.toString('base64');
+  } catch (error) {
+    throw new Error(`Stream encryption failed: ${error.message}`);
+  }
+};
+
+exports.decryptFile = async (ciphertext, secretKey, options = {}) => {
+  try {
+    const onProgress = options.onProgress || null;
+    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 dataHash = data.slice(-ARGON2_HASH_LENGTH);
+    const argon2Salt = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE, -ARGON2_HASH_LENGTH);
+    const tag1 = data.slice(-ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+    const encrypted = data.slice(SALT_SIZE + 5 * IV_SIZE, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE - TAG_SIZE);
+
+    const dataToVerify = data.slice(0, -ARGON2_HASH_LENGTH - ARGON2_SALT_SIZE);
+
+    if (!(await verifyHash(dataToVerify, dataHash, argon2Salt))) {
+      throw new Error('Data integrity check failed');
+    }
+
+    const encryptedData = { salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1 };
+    const decrypted = await exports.decryptStream(encryptedData, secretKey, onProgress);
+    const decompressed = await decompress(decrypted);
+
+    return decompressed.toString('utf8');
+  } catch (error) {
+    throw new Error(`Stream decryption failed: ${error.message}`);
+  }
+};