Merge pull request #1496 from Hirobreak/backup-worker

Backup worker

Author: Hirobreak

electron_app/src/BackupManager.js

@@ -4,13 +4,9 @@ const zlib = require('zlib');
 const { app } = require('electron');
 const myAccount = require('./Account');
 const { databasePath } = require('./database/DBEmodel');
-const { backupFilenameRegex } = require('./utils/RegexUtils');
-const { createPathRecursive, store } = require('./utils/FileUtils');
+const { createPathRecursive } = require('./utils/FileUtils');
 const {
   decryptStreamFileWithPassword,
-  encryptStreamFile,
-  exportEncryptDatabaseToFile,
-  generateKeyAndIvFromPassword,
   importDatabaseFromFile
 } = require('./database/DBEexporter');
 
@@ -21,13 +17,6 @@ const STREAM_SIZE = 512 * 1024;
 const TempBackupFolderName = 'BackupData';
 const TempBackupDirectory = path.join(databasePath, '..', TempBackupFolderName);
 
-const ExportUnencryptedFilename = path.join(
-  TempBackupDirectory,
-  'unencrypt.exp'
-);
-const ExportZippedFilename = path.join(TempBackupDirectory, 'zipped.exp');
-const ExportEncryptedFilename = path.join(TempBackupDirectory, 'encrypted.exp');
-
 const RestoreUnzippedFilename = path.join(TempBackupDirectory, 'unzipped.res');
 const RestoreUnencryptedFilename = path.join(
   TempBackupDirectory,
@@ -61,18 +50,6 @@ const removeTempBackupDirectoryRecursive = pathToDelete => {
   }
 };
 
-const cleanPreviousBackupFilesInFolder = pathToClean => {
-  try {
-    const files = fs.readdirSync(pathToClean);
-    const filtered = files.filter(name => backupFilenameRegex.test(name));
-    filtered.forEach(filename => {
-      fs.unlinkSync(path.join(pathToClean, filename));
-    });
-  } catch (cleanErr) {
-    return cleanErr;
-  }
-};
-
 /*  Default Directory
 ----------------------------- */
 function getUsername() {
@@ -96,19 +73,6 @@ const createDefaultBackupFolder = () => {
 /*  Methods
 ----------------------------- */
 
-const zipStreamFile = ({ inputFile, outputFile }) => {
-  return new Promise((resolve, reject) => {
-    const highWaterMark = STREAM_SIZE;
-    const reader = fs.createReadStream(inputFile, { highWaterMark });
-    const writer = fs.createWriteStream(outputFile);
-    reader
-      .pipe(zlib.createGzip())
-      .pipe(writer)
-      .on('error', reject)
-      .on('finish', resolve);
-  });
-};
-
 const unzipStreamFile = ({ inputFile, outputFile }) => {
   return new Promise((resolve, reject) => {
     const highWaterMark = STREAM_SIZE;
@@ -131,95 +95,6 @@ const prepareBackupFiles = () => {
   }
 };
 
-const getFileSizeInBytes = filename => {
-  try {
-    const stats = fs.statSync(filename);
-    return stats.size;
-  } catch (error) {
-    return 0;
-  }
-};
-
-/*  Export Backup 
------------------------------ */
-const exportBackupUnencrypted = async ({
-  backupPath,
-  accountObj,
-  progressCallback
-}) => {
-  try {
-    try {
-      await exportEncryptDatabaseToFile({
-        outputPath: ExportUnencryptedFilename,
-        accountObj,
-        progressCallback
-      });
-    } catch (dbErr) {
-      throw new Error('Failed to export database');
-    }
-    // Compress backup file
-    try {
-      await zipStreamFile({
-        inputFile: ExportUnencryptedFilename,
-        outputFile: ExportZippedFilename
-      });
-    } catch (zipErr) {
-      throw new Error('Failed to compress backup file');
-    }
-    // Move to destination
-    try {
-      cleanPreviousBackupFilesInFolder(path.join(backupPath, '..'));
-      await store(backupPath, fs.readFileSync(ExportZippedFilename));
-    } catch (fileErr) {
-      throw new Error('Failed to move backup file');
-    }
-    return getFileSizeInBytes(backupPath);
-  } catch (exportBackupError) {
-    throw exportBackupError;
-  } finally {
-    removeTempBackupDirectoryRecursive(TempBackupDirectory);
-  }
-};
-
-const exportBackupEncrypted = async ({ backupPath, password, accountObj }) => {
-  try {
-    // Export database
-    try {
-      await exportEncryptDatabaseToFile({
-        outputPath: ExportUnencryptedFilename,
-        accountObj
-      });
-    } catch (dbErr) {
-      throw new Error('Failed to export database');
-    }
-    // GZip & Encrypt
-    try {
-      const { key, iv, salt } = generateKeyAndIvFromPassword(password);
-      await encryptStreamFile({
-        inputFile: ExportUnencryptedFilename,
-        outputFile: ExportEncryptedFilename,
-        key,
-        iv,
-        salt
-      });
-    } catch (encryptErr) {
-      throw new Error('Failed to encrypt backup');
-    }
-    // Move to destination
-    try {
-      cleanPreviousBackupFilesInFolder(path.join(backupPath, '..'));
-      await store(backupPath, fs.readFileSync(ExportEncryptedFilename));
-    } catch (fileErr) {
-      throw new Error('Failed to create backup file');
-    }
-    return getFileSizeInBytes(backupPath);
-  } catch (exportBackupError) {
-    throw exportBackupError;
-  } finally {
-    removeTempBackupDirectoryRecursive(TempBackupDirectory);
-  }
-};
-
 /*  Restore Backup 
 ----------------------------- */
 const restoreUnencryptedBackup = async ({ filePath }) => {
@@ -280,8 +155,6 @@ const restoreEncryptedBackup = async ({ filePath, password }) => {
 module.exports = {
   createDefaultBackupFolder,
   getDefaultBackupFolder,
-  exportBackupUnencrypted,
-  exportBackupEncrypted,
   prepareBackupFiles,
   restoreUnencryptedBackup,
   restoreEncryptedBackup

electron_app/src/backup/Compress.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const crypto = require('crypto');
+const zlib = require('zlib');
+
+const CIPHER_ALGORITHM = 'aes-128-cbc';
+const STREAM_SIZE = 512 * 1024;
+const DEFAULT_KEY_LENGTH = 16;
+
+const zipStreamFile = ({ inputFile, outputFile }) => {
+  return new Promise((resolve, reject) => {
+    const highWaterMark = STREAM_SIZE;
+    const reader = fs.createReadStream(inputFile, { highWaterMark });
+    const writer = fs.createWriteStream(outputFile);
+    reader
+      .pipe(zlib.createGzip())
+      .pipe(writer)
+      .on('error', reject)
+      .on('finish', resolve);
+  });
+};
+
+const encryptStreamFile = ({ inputFile, outputFile, key, iv, salt }) => {
+  return new Promise((resolve, reject) => {
+    const reader = fs.createReadStream(inputFile, {
+      highWaterMark: STREAM_SIZE
+    });
+    const writer = fs.createWriteStream(outputFile);
+    if (salt) writer.write(salt);
+    writer.write(iv);
+
+    reader
+      .pipe(zlib.createGzip())
+      .pipe(crypto.createCipheriv(CIPHER_ALGORITHM, key, iv))
+      .pipe(writer)
+      .on('error', reject)
+      .on('finish', resolve);
+  });
+};
+
+const generateKeyAndIvFromPassword = (password, customSalt) => {
+  const salt = customSalt || crypto.randomBytes(8);
+  const iterations = 10000;
+  const pbkdf2Name = 'sha256';
+  const key = crypto.pbkdf2Sync(
+    Buffer.from(password, 'utf8'),
+    salt,
+    iterations,
+    DEFAULT_KEY_LENGTH,
+    pbkdf2Name
+  );
+  const iv = crypto.randomBytes(DEFAULT_KEY_LENGTH);
+  return { key, iv, salt };
+};
+
+module.exports = {
+  zipStreamFile,
+  generateKeyAndIvFromPassword,
+  encryptStreamFile
+};

electron_app/src/backup/FileUtils.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+
+const removeTempBackupDirectoryRecursive = pathToDelete => {
+  if (fs.existsSync(pathToDelete)) {
+    fs.readdirSync(pathToDelete).forEach(file => {
+      const currentPath = path.join(pathToDelete, file);
+      if (fs.lstatSync(currentPath).isDirectory()) {
+        removeTempBackupDirectoryRecursive(currentPath);
+      } else {
+        fs.unlinkSync(currentPath);
+      }
+    });
+    fs.rmdirSync(pathToDelete);
+  }
+};
+
+const checkTempBackupDirectory = tempBackupDirectory => {
+  try {
+    if (fs.existsSync(tempBackupDirectory)) {
+      removeTempBackupDirectoryRecursive(tempBackupDirectory);
+    }
+    fs.mkdirSync(tempBackupDirectory);
+  } catch (e) {
+    throw new Error('Unable to create temp folder');
+  }
+};
+
+const getFileSizeInBytes = filename => {
+  try {
+    const stats = fs.statSync(filename);
+    return stats.size;
+  } catch (error) {
+    return 0;
+  }
+};
+
+const copyDatabase = (dbPath, tempBackupDirectory) => {
+  const dbshm = `${dbPath}-shm`;
+  const dbwal = `${dbPath}-wal`;
+
+  if (!fs.existsSync(dbPath)) {
+    throw new Error('No Database Found');
+  }
+
+  fs.copyFileSync(dbPath, path.join(tempBackupDirectory, 'CriptextEncrypt.db'));
+
+  if (fs.existsSync(dbshm)) {
+    fs.copyFileSync(
+      dbshm,
+      path.join(tempBackupDirectory, 'CriptextEncrypt.db-shm')
+    );
+  }
+  if (fs.existsSync(dbwal)) {
+    fs.copyFileSync(
+      dbwal,
+      path.join(tempBackupDirectory, 'CriptextEncrypt.db-wal')
+    );
+  }
+};
+
+module.exports = {
+  getFileSizeInBytes,
+  checkTempBackupDirectory,
+  removeTempBackupDirectoryRecursive,
+  copyDatabase
+};