backup + decriptare toate fisiere done

2024-04-19 16:48:10 +03:00
parent ffeebf1177
commit 869305a491
55 changed files with 1073 additions and 265 deletions
@@ -0,0 +1,217 @@
+const fs = require('fs').promises;  // Ensure you use the promise-based API
+const path = require('path');
+const { decryptFileInPlace, encryptFileInPlace, encryptFileWithKey, decryptFileWithKey} = require("../src/main/aes_encrypt");
+const {lockFile, unlockFile} = require("../helpers/lock_mechanism");
+
+function extractFilePaths(directoryStructure) {
+    let paths = [];
+    const traverse = (dir, currentPath) => {
+        Object.keys(dir).forEach(key => {
+            if (key === 'files') {
+                dir[key].forEach(file => paths.push(path.join(currentPath, file)));
+            } else {
+                traverse(dir[key], path.join(currentPath, key));
+            }
+        });
+    };
+    traverse(directoryStructure, '');
+    return paths;
+}
+
+async function fetchFiles(ip, filePaths) {
+    let results = {};
+
+    for (const filePath of filePaths) {
+        const url = `http://${ip}:3000/file_path`;
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ filePath })
+            });
+
+            if (!response.ok) throw new Error(`HTTP status ${response.status}`);
+
+            const arrayBuffer = await response.arrayBuffer(); // Fetch the response as an ArrayBuffer
+            results[filePath] = Buffer.from(arrayBuffer);
+        } catch (error) {
+            console.error(`Error fetching ${filePath}:`, error);
+            results[filePath] = null;
+        }
+    }
+
+    return results;
+}
+
+async function removeDirectory(directoryPath) {
+    try {
+        // Check if the directory exists
+        const stats = await fs.stat(directoryPath);
+        if (!stats.isDirectory()) {
+            console.log('The specified path is not a directory.');
+            return;
+        }
+
+        // Read all the contents of the directory
+        const files = await fs.readdir(directoryPath);
+
+        // Loop through each file/directory and delete them
+        for (const file of files) {
+            const currentPath = path.join(directoryPath, file);
+            const currentStats = await fs.stat(currentPath);
+
+            if (currentStats.isDirectory()) {
+                // Recursive call for directories
+                await removeDirectory(currentPath);
+            } else {
+                // Delete file
+                await fs.unlink(currentPath);
+            }
+        }
+
+        // Finally, delete the directory itself
+        await fs.rmdir(directoryPath);
+        //console.log(`Directory removed: ${directoryPath}`);
+    } catch (error) {
+        console.error(`Error removing directory: ${error.message}`);
+    }
+}
+
+async function decryptUserSystemConfig() {
+    const configPath = path.join(__dirname, '..', 'usersInSystem.json');
+    await lockFile(configPath);
+    await decryptFileInPlace(configPath);
+}
+
+async function encryptUserSystemConfig(){
+    const configPath = path.join(__dirname, '..', 'usersInSystem.json');
+    await unlockFile(configPath);
+    await encryptFileInPlace(configPath);
+}
+
+async function processBackup() {
+    await decryptUserSystemConfig();
+    const usersConfigPath = path.join(__dirname, '..', 'usersInSystem.json');
+    const backupConfigPath = path.join(__dirname, '..', 'backupSchemes.json');
+    const baseBackupDirPath = path.join(__dirname, '..', 'backup_directories');
+
+    try {
+        // Read and parse the users configuration
+        const usersData = await fs.readFile(usersConfigPath, 'utf8');
+        const usersConfig = JSON.parse(usersData);
+
+        // Read and parse the backup configuration
+        const backupData = await fs.readFile(backupConfigPath, 'utf8');
+        const jsonData = JSON.parse(backupData);
+
+        for (const key in jsonData) {
+            const userBackupDir = path.join(baseBackupDirPath, key);
+            await removeDirectory(userBackupDir);
+
+            const node = jsonData[key];
+            const directoryStructure = JSON.parse(node.directoryStructure);
+            const filePaths = extractFilePaths(directoryStructure);
+            const files = await fetchFiles(node.ip, filePaths);
+
+            await fs.mkdir(userBackupDir, { recursive: true });
+
+            // Find the encryption key for the user's department
+            let encryptionKey = '';
+            for (const dept in usersConfig) {
+                if (usersConfig[dept].users.includes(key)) {
+                    encryptionKey = usersConfig[dept].key;
+                    break;
+                }
+            }
+
+            for (const file in files) {
+                if (files[file]) {
+                    const fullPath = path.join(userBackupDir, file);
+                    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                    await fs.writeFile(fullPath, files[file]); // Write the binary data
+
+                    // Encrypt the file in place after writing it
+                    if (encryptionKey) {
+                        await encryptFileWithKey(fullPath, encryptionKey);
+                    }
+                }
+            }
+        }
+    } catch (error) {
+        console.error('Failed to read or process the JSON file:', error);
+    }
+
+    await encryptUserSystemConfig();
+}
+
+async function getAllFilePaths(dirPath) {
+    let filePaths = [];
+    async function recurse(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        // Create promises for each entry and process them in parallel
+        const entryPromises = entries.map(async (entry) => {
+            const resolvedPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                // If it's a directory, recurse into it
+                await recurse(resolvedPath);
+            } else {
+                // If it's a file, add it to the file paths array
+                filePaths.push(resolvedPath);
+            }
+        });
+        // Wait for all promises to complete
+        await Promise.all(entryPromises);
+    }
+    await recurse(dirPath);
+    return filePaths;
+}
+
+async function decryptUserFilesToDirectory(destinationDir) {
+    await decryptUserSystemConfig();  // Ensure user config is decrypted
+    const usersConfigPath = path.join(__dirname, '..', 'usersInSystem.json');
+    const usersConfig = JSON.parse(await fs.readFile(usersConfigPath, 'utf8'));
+    const sourceDir = path.join(__dirname, '..', 'backup_directories');
+
+    try {
+        for (const department in usersConfig) {
+            const { key, users } = usersConfig[department];
+            for (const userId of users) {
+                const userDir = path.join(sourceDir, userId);
+                try {
+                    const files = await getAllFilePaths(userDir);
+                    for (const filePath of files) {
+                        const stats = await fs.stat(filePath);
+                        if (stats.isFile()) {
+                            // Extract the part of the file path after the userId
+                            const relativePath = path.relative(userDir, filePath);
+
+                            // Construct the destination file path
+                            const destinationFilePath = path.join(destinationDir, userId, relativePath);
+                            await fs.mkdir(path.dirname(destinationFilePath), { recursive: true });
+
+                            // Decrypt the file in its original location
+                            await decryptFileWithKey(filePath, key);
+
+                            // Copy the decrypted file to the destination directory
+                            await fs.copyFile(filePath, destinationFilePath);
+                            console.log(`Decrypted file copied to: ${destinationFilePath}`);
+
+                            // Re-encrypt the file in its original location (optional)
+                            await encryptFileWithKey(filePath, key);
+                        }
+                    }
+                } catch (error) {
+                    console.error(`Error processing files for user ${userId}: ${error.message}`);
+                }
+            }
+        }
+    } catch (error) {
+        console.error(`Error processing decryption: ${error.message}`);
+    }
+}
+
+
+processBackup();
+decryptUserFilesToDirectory("C:\\Users\\Andrei Cerbu\\Documents\\decrypted");
@@ -0,0 +1,79 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const Joi = require('joi');
+const fetch = require('node-fetch');
+const { httpStatus } = require('../helpers/http_status');
+
+const app = express();
+app.use(express.json());
+
+const filePathSchema = Joi.object({
+    filePath: Joi.string().required()
+});
+
+async function getBaseDirectory() {
+    const filePath = path.join(__dirname, '..', 'dirBackup.json');
+    try {
+        const data = await fs.promises.readFile(filePath, 'utf8');
+        const jsonData = JSON.parse(data);
+        return jsonData.path;
+    } catch (error) {
+        console.error('Error reading the base directory:', error);
+        throw error;
+    }
+}
+
+app.post('/file_path', async (req, res) => {
+    const { error, value } = filePathSchema.validate(req.body);
+    if (error) {
+        return res.status(httpStatus.BAD_REQUEST).json({
+            message: 'Invalid input',
+            data: error.details
+        });
+    }
+
+    try {
+        const basePath = await getBaseDirectory();
+        let { filePath } = value;
+        const baseDirName = path.basename(basePath);
+        if (filePath.startsWith(baseDirName + path.sep)) {
+            filePath = filePath.slice(baseDirName.length + 1);
+        }
+        const fullPath = path.resolve(basePath, filePath);
+
+        fs.stat(fullPath, (err, stats) => {
+            if (err) {
+                if (err.code === 'ENOENT') {
+                    return res.status(httpStatus.NOT_FOUND).json({
+                        message: 'File not found'
+                    });
+                }
+                return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({
+                    message: 'Error accessing the file'
+                });
+            }
+
+            if (!stats.isFile()) {
+                return res.status(httpStatus.BAD_REQUEST).json({
+                    message: 'Path is not a file'
+                });
+            }
+
+            // Stream the file as binary data
+            res.writeHead(httpStatus.OK, {
+                'Content-Type': 'application/octet-stream',
+                'Content-Disposition': `attachment; filename="${path.basename(fullPath)}"`
+            });
+            const fileStream = fs.createReadStream(fullPath);
+            fileStream.pipe(res);
+        });
+    } catch (error) {
+        return res.status(httpStatus.INTERNAL_SERVER_ERROR).json({
+            message: 'Error processing request'
+        });
+    }
+});
+
+const PORT = process.env.PORT || 3000;
+app.listen(PORT, () => console.log(`Server running on port ${PORT}`));
@@ -0,0 +1,209 @@
+const fs = require('fs').promises;
+const path = require('path');
+const ip = require('ip');
+const {encryptFileInPlace, decryptFileInPlace} = require('../src/main/aes_encrypt');
+const {lockFile, unlockFile} = require("../helpers/lock_mechanism");
+
+async function fetchBackupSchemes(serverIp) {
+    // Fetching backup schemes from the server
+    const depResponse = await fetch(`http://${serverIp}/backup_schemes`, {
+        method: 'GET',
+        headers: {'x-api-key': 'uc_api'}
+    });
+    const backupSchemesJson = await depResponse.json();
+    const backupSchemes = backupSchemesJson['data'];
+
+    // Specify the path where the backup schemes will be saved
+    const destPath = path.join(__dirname, '..', 'backupSchemes.json');
+
+    // Write the fetched backup schemes to the specified file
+    try {
+        await lockFile(destPath);
+        await fs.writeFile(destPath, JSON.stringify(backupSchemes, null, 2)); // Use null, 2 for pretty formatting
+        await unlockFile(destPath);
+        console.log('Backup schemes saved successfully to', destPath);
+    } catch (error) {
+        console.error('Failed to save backup schemes:', error);
+    }
+}
+
+async function fetchUsersAndDepartments(serverIp) {
+    try {
+        // Fetch departments
+        const depResponse = await fetch(`http://${serverIp}/users/departments`, {
+            method: 'GET',
+            headers: {'x-api-key': 'uc_api'}
+        });
+        const departmentsJson = await depResponse.json();
+        const departments = departmentsJson['data'];
+
+        // Fetch users
+        const userResponse = await fetch(`http://${serverIp}/users`, {
+            method: 'GET',
+            headers: {'x-api-key': 'uc_api'}
+        });
+        const usersJson = await userResponse.json();
+        const users = usersJson['data'];
+
+        // Combine the JSON data
+        const combinedData = Object.values(departments).reduce((acc, {name, key}) => {
+            acc[name] = {
+                key,
+                users: users.filter(user => user.department === name).map(user => user.id)
+            };
+            return acc;
+        }, {});
+
+        // Write combined data to a file
+        const filePath = path.join(__dirname, '..', 'usersInSystem.json');
+        await lockFile(filePath);
+        await fs.writeFile(filePath, JSON.stringify(combinedData, null, 2), 'utf8');
+
+        await encryptFileInPlace(filePath);
+        await unlockFile(filePath);
+        console.log('Data has been encrypted and saved.');
+    } catch (error) {
+        console.error('Failed to fetch or process data:', error);
+    }
+}
+
+async function decryptAndGetServerIP(filePath) {
+    try {
+        await lockFile(filePath);
+        await decryptFileInPlace(filePath);
+
+        const fileContent = await fs.readFile(filePath, 'utf8');
+        const jsonData = JSON.parse(fileContent);
+        const serverIP = jsonData.ip;
+
+        await encryptFileInPlace(filePath)
+        await unlockFile(filePath);
+        return serverIP;
+    } catch (error) {
+        console.error('An error occurred:', error);
+        return null;
+    }
+}
+
+async function getDirectoryStructure(dirPath) {
+    const baseName = path.basename(dirPath);
+    const entries = await fs.readdir(dirPath, {withFileTypes: true});
+    const result = {};
+    result[baseName] = {files: []};
+    let totalSize = 0;
+
+    for (let entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            // Recursively get structure for subdirectories
+            const {structure, size: subSize} = await getDirectoryStructure(entryPath);
+            result[baseName][entry.name] = structure[Object.keys(structure)[0]]; // Object.keys to fetch the first key name
+            totalSize += subSize;
+        } else {
+            // Add file name to the 'files' array and calculate total size
+            const stats = await fs.stat(entryPath);
+            result[baseName].files.push(entry.name);
+            totalSize += stats.size;
+        }
+    }
+    return {structure: result, size: totalSize};
+}
+
+async function createBackupScheme(serverIp, structure, size) {
+    let filePath = path.join(__dirname, '..', 'loginData.json');
+    await lockFile(filePath);
+    await decryptFileInPlace(filePath);
+
+    const userContent = await fs.readFile(filePath, 'utf8');
+    const userJson = JSON.parse(userContent);
+
+    await encryptFileInPlace(filePath)
+    await unlockFile(filePath);
+
+    // Find the IP address of the machine
+    const machineIP = ip.address();
+
+    // Prepare the data to be sent
+    const dataToSend = {
+        id: userJson.id,
+        ip: machineIP,
+        directoryStructure: JSON.stringify(structure),
+        totalSize: size
+    };
+
+    const response = await fetch(`http://${serverIp}/backup_schemes`, {
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': 'uc_api'
+        },
+        body: JSON.stringify(dataToSend)
+    });
+
+    if (response.ok) {
+        console.log("Backup dir structure submitted.")
+    } else {
+        const data = await response.json()
+        console.log(data.message);
+    }
+}
+
+async function watchDirectoryChanges(serverIp) {
+    async function readBackupConfig(filePath) {
+        await lockFile(filePath);
+        const fileContent = await fs.readFile(filePath, 'utf8');
+        await unlockFile(filePath);
+        return JSON.parse(fileContent);
+    }
+
+    async function updateBackupConfig(filePath, structure, size) {
+        const data = {
+            path: filePath,
+            structure: structure,
+            size: size
+        };
+        await lockFile(filePath);
+        await fs.writeFile(path.join(__dirname, '..', 'dirBackup.json'), JSON.stringify(data, null, 2));
+        await unlockFile(filePath);
+    }
+
+    const configPath = path.join(__dirname, '..', 'dirBackup.json');
+    const backupConfig = await readBackupConfig(configPath);
+    const storedStructure = backupConfig.structure;
+
+    const {structure: currentStructure, size: currentSize} = await getDirectoryStructure(backupConfig.path);
+
+    if (JSON.stringify(storedStructure) !== JSON.stringify(currentStructure)) {
+        console.log("Directory structure has changed. Updating backup...");
+        await createBackupScheme(serverIp, currentStructure, currentSize);
+
+        await updateBackupConfig(backupConfig.path, currentStructure, currentSize);
+    } else {
+        console.log("No changes detected in the directory structure.");
+    }
+}
+
+process.on('SIGINT', () => {
+    console.log('Process terminated');
+    process.exit(0);
+});
+
+let serverIp = null
+decryptAndGetServerIP(path.join(__dirname, '..', 'ipConfig.json')).then(ip => {
+    serverIp = ip;
+});
+
+setInterval(() => {
+    fetchUsersAndDepartments(serverIp);
+}, 5000);
+
+setInterval(() => {
+    watchDirectoryChanges(serverIp);
+}, 5000);
+
+setInterval(() => {
+    fetchBackupSchemes(serverIp);
+}, 5000);
+
+
+console.log("Service running. Press CTRL+C to stop.");