k9crypt 1.1.7 → 1.1.8

package/README.md

@@ -6,10 +6,13 @@ This is a special encryption algorithm created for K9Crypt.
 
 ## Updates
 
-**v1.1.7**
+**v1.1.8**
 
-- The Argon2 hashing system has now been integrated, offering support for both SHA512 and Argon2.
-- Encryption performance has been optimized, significantly increasing speed.
+- 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
 
@@ -22,6 +25,8 @@ bun add k9crypt
 
 ## Usage
 
+### Basic Usage
+
 ```javascript
 const k9crypt = require('k9crypt');
 
@@ -46,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.7",
+  "version": "1.1.8",
   "description": "A special encryption algorithm created for K9Crypt.",
   "main": "index.js",
   "scripts": {

package/src/index.js

@@ -3,36 +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 { 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 } = await encrypt(compressed, key);
-      const dataToHash = Buffer.concat([ salt, iv1, iv2, iv3, iv4, iv5, encrypted, tag1 ]);
+      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 ]);
+      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}`);
     }
   }
 
@@ -52,16 +60,90 @@ class K9crypt {
       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))) {
-        console.log('Data integrity check failed');
+        throw new Error('Data integrity check failed');
       }
 
       const key = await deriveKey(this.secretKey, salt);
       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,12 +1,19 @@
 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]: 4,
+        [zlib.constants.BROTLI_PARAM_QUALITY]: brotliQuality,
         [zlib.constants.BROTLI_PARAM_SIZE_HINT]: Buffer.byteLength(data, 'utf8'),
         [zlib.constants.BROTLI_PARAM_LGWIN]: 24
       }
@@ -18,12 +25,12 @@ exports.compress = async (data) => {
         brotliParams,
         (err, compressed) => {
           if (err) reject(err);
-          else resolve(compressed);
+          if (!err) resolve(compressed);
         }
       );
     });
 
-    const lzmaCompressed = await lzma.compress(brotliCompressed, 3);
+    const lzmaCompressed = await lzma.compress(brotliCompressed, lzmaLevel);
     return lzmaCompressed;
   } catch (error) {
     throw new Error(`Compression error: ${error.message}`);

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}`);
+  }
+};