Creation

src/util/crypto_helper.rs

@@ -0,0 +1,143 @@
+use aes_gcm::{
+    Aes256Gcm, Nonce,
+    aead::{Aead, KeyInit, OsRng},
+};
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use rand_core::RngCore;
+use sha2::{Digest, Sha256};
+use x448::{PublicKey, Secret, SharedSecret};
+
+/// Errors for crypto operations
+#[derive(Debug)]
+pub enum CryptoError {
+    Base64Decode(base64::DecodeError),
+    InvalidKey,
+    AgreementError,
+    EncryptionError(aes_gcm::Error),
+    DecryptionError(aes_gcm::Error),
+}
+
+impl From<base64::DecodeError> for CryptoError {
+    fn from(err: base64::DecodeError) -> Self {
+        CryptoError::Base64Decode(err)
+    }
+}
+
+pub struct KeyPair {
+    pub secret: Secret,
+    pub public: PublicKey,
+}
+
+pub fn generate_keypair() -> KeyPair {
+    let mut buf = [0u8; 56];
+    let mut rng = OsRng;
+    rng.fill_bytes(&mut buf);
+    let secret = Secret::from_bytes(&buf).unwrap();
+    let public = PublicKey::from(&secret);
+    KeyPair { secret, public }
+}
+
+pub fn public_key_to_base64(pubkey: &PublicKey) -> String {
+    STANDARD.encode(pubkey.as_bytes().as_ref())
+}
+
+pub fn secret_key_to_base64(secret: &Secret) -> String {
+    STANDARD.encode(secret.as_bytes().as_ref())
+}
+
+pub fn load_public_key(base64_pub: &str) -> Option<PublicKey> {
+    let bytes = STANDARD.decode(base64_pub).unwrap();
+    PublicKey::from_bytes(&bytes)
+}
+
+pub fn load_secret_key(base64_secret: &str) -> Option<Secret> {
+    let bytes = STANDARD.decode(base64_secret).unwrap();
+    Secret::from_bytes(&bytes)
+}
+
+fn derive_aes_key(shared: &SharedSecret) -> [u8; 32] {
+    let mut hasher = Sha256::new();
+    hasher.update(shared.as_bytes());
+    let result = hasher.finalize();
+    let mut key = [0u8; 32];
+    key.copy_from_slice(&result[..32]);
+    key
+}
+
+pub fn encrypt_b64(
+    base64_secret: &str,
+    base64_peer_pub: &str,
+    plaintext: &str,
+) -> Result<String, CryptoError> {
+    let secret = load_secret_key(base64_secret).unwrap();
+    let peer_pub = load_public_key(base64_peer_pub).unwrap();
+    encrypt(secret, peer_pub, plaintext)
+}
+pub fn encrypt(
+    secret: Secret,
+    peer_pub: PublicKey,
+    plaintext: &str,
+) -> Result<String, CryptoError> {
+    let shared = secret
+        .to_diffie_hellman(&peer_pub)
+        .ok_or(CryptoError::AgreementError)?;
+    let key_bytes = derive_aes_key(&shared);
+    let cipher = Aes256Gcm::new_from_slice(&key_bytes).expect("Key length should be correct");
+    let mut nonce_bytes = [0u8; 12];
+    OsRng.fill_bytes(&mut nonce_bytes);
+    let nonce = Nonce::from_slice(&nonce_bytes);
+    let ciphertext = cipher
+        .encrypt(nonce, plaintext.as_bytes())
+        .map_err(CryptoError::EncryptionError)?;
+    // prefix nonce to ciphertext
+    let mut out = Vec::with_capacity(nonce_bytes.len() + ciphertext.len());
+    out.extend_from_slice(&nonce_bytes);
+    out.extend_from_slice(&ciphertext);
+    Ok(STANDARD.encode(&out))
+}
+
+pub fn decrypt_b64(
+    base64_secret: &str,
+    base64_peer_pub: &str,
+    encrypted_base64: &str,
+) -> Result<String, CryptoError> {
+    let secret = load_secret_key(base64_secret).unwrap();
+    let peer_pub = load_public_key(base64_peer_pub).unwrap();
+    decrypt(secret, peer_pub, encrypted_base64)
+}
+pub fn decrypt(
+    secret: Secret,
+    peer_pub: PublicKey,
+    encrypted_base64: &str,
+) -> Result<String, CryptoError> {
+    let shared = secret
+        .to_diffie_hellman(&peer_pub)
+        .ok_or(CryptoError::AgreementError)?;
+    let key_bytes = derive_aes_key(&shared);
+    let cipher = Aes256Gcm::new_from_slice(&key_bytes).expect("Key length should be correct");
+
+    let encrypted = STANDARD.decode(encrypted_base64)?;
+    if encrypted.len() < 12 {
+        return Err(CryptoError::DecryptionError(aes_gcm::Error));
+    }
+    let nonce_bytes = &encrypted[..12];
+    let ciphertext = &encrypted[12..];
+    let nonce = Nonce::from_slice(nonce_bytes);
+    let plaintext_bytes = cipher
+        .decrypt(nonce, ciphertext)
+        .map_err(CryptoError::DecryptionError)?;
+    let plaintext = String::from_utf8(plaintext_bytes)
+        .map_err(|_| CryptoError::DecryptionError(aes_gcm::Error))?;
+    Ok(plaintext)
+}
+
+pub fn hash_it(input: &str) -> Vec<u8> {
+    let mut hasher = Sha256::new();
+    hasher.update(input.as_bytes());
+    hasher.finalize().to_vec()
+}
+
+pub fn hex_hash(input: &str) -> String {
+    let digest = hash_it(input);
+    digest.iter().map(|b| format!("{:02x}", b)).collect()
+}

src/util/file_util.rs

@@ -0,0 +1,350 @@
+use crate::log;
+use std::ffi::OsStr;
+use std::fs::{self, File};
+use std::io::{self, BufReader, Read};
+use std::path::{Path, PathBuf};
+use sysinfo::System;
+use uuid::Uuid;
+use walkdir::WalkDir;
+use zip::ZipArchive;
+
+pub fn delete_file(path: &str, name: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+    let file = dir.join(name);
+    if !file.exists() {
+        return false;
+    }
+    fs::remove_file(file).is_ok()
+}
+
+pub fn delete_directory(path: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+    delete_dir_recursive(&dir)
+}
+
+fn delete_dir_recursive(directory: &Path) -> bool {
+    if !directory.exists() {
+        return false;
+    }
+    if let Err(e) = fs::remove_dir_all(directory) {
+        log!(
+            "[IMPORTANT] Couldn't delete directory {}: {}",
+            directory.display(),
+            e
+        );
+        return false;
+    }
+    true
+}
+
+pub fn load_file_buf(path: &str, name: &str) -> io::Result<BufReader<File>> {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    // Ensure the directory exists, create if necessary
+    if !dir.exists() {
+        if let Err(_) = fs::create_dir_all(&dir) {
+            return Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "Directory creation failed",
+            ));
+        }
+    }
+
+    // Create the file if it doesn't exist
+    if !file_path.exists() {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "File creation failed",
+        ));
+    }
+
+    // Open the file and return a BufReader for efficient reading
+    let file = File::open(&file_path)?;
+    Ok(BufReader::new(file))
+}
+pub fn has_file(path: &str, name: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        return false;
+    }
+
+    if !file_path.exists() {
+        return false;
+    }
+
+    true
+}
+pub fn has_dir(path: &str) -> bool {
+    let dir = Path::new(&get_directory()).join(path);
+
+    if !dir.exists() {
+        return false;
+    }
+
+    true
+}
+
+pub fn load_file(path: &str, name: &str) -> String {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        if let Err(e) = fs::create_dir_all(&dir) {
+            log!("[IMPORTANT] Couldn't create directories: {}", e);
+            return String::new();
+        }
+        return String::new();
+    }
+
+    if !file_path.exists() {
+        if let Err(e) = File::create(&file_path) {
+            log!("[IMPORTANT] Couldn't create file: {}", e);
+        }
+        return String::new();
+    }
+
+    let mut content = String::new();
+    if let Ok(mut f) = File::open(&file_path) {
+        let _ = f.read_to_string(&mut content);
+    }
+    content
+}
+
+pub fn load_file_vec(path: &str, name: &str) -> Vec<u8> {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        if let Err(e) = fs::create_dir_all(&dir) {
+            log!("[IMPORTANT] Couldn't create directories: {}", e);
+            return Vec::new();
+        }
+        return Vec::new();
+    }
+
+    if !file_path.exists() {
+        if let Err(e) = File::create(&file_path) {
+            log!("[IMPORTANT] Couldn't create file: {}", e);
+        }
+        return Vec::new();
+    }
+
+    let mut content = Vec::new();
+    if let Ok(mut f) = File::open(&file_path) {
+        let _ = f.read_to_end(&mut content);
+    }
+    content
+}
+pub fn save_file(path: &str, name: &str, value: &str) {
+    let dir = Path::new(&get_directory()).join(path);
+    let file_path = dir.join(name);
+
+    if !dir.exists() {
+        if let Err(e) = fs::create_dir_all(&dir) {
+            log!("[IMPORTANT] Couldn't create directories: {}", e);
+            return;
+        }
+    }
+
+    if let Err(e) = fs::write(&file_path, value) {
+        log!(
+            "[IMPORTANT] Couldn't write file {}: {}",
+            file_path.display(),
+            e
+        );
+    }
+}
+
+pub fn get_children(path: &str) -> Vec<String> {
+    let dir = Path::new(&get_directory()).join(path);
+    let mut children = Vec::new();
+    if let Ok(entries) = fs::read_dir(&dir) {
+        for entry in entries {
+            if let Ok(entry) = entry {
+                children.push(entry.file_name().to_string_lossy().to_string());
+            }
+        }
+    }
+    children
+}
+
+pub fn get_directory() -> String {
+    let exe = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
+    exe.parent()
+        .unwrap_or(Path::new("."))
+        .to_string_lossy()
+        .to_string()
+}
+
+pub fn used_space() -> u64 {
+    get_directory_size(&PathBuf::from(get_directory()))
+}
+pub fn used_dir_space(path: &str) -> u64 {
+    get_directory_size(&PathBuf::from(format!("{}/{}", get_directory(), path)))
+}
+
+pub fn get_directory_size(directory: &Path) -> u64 {
+    let mut size = 0;
+    for entry in WalkDir::new(directory).into_iter().filter_map(|e| e.ok()) {
+        let path = entry.path();
+        if path.is_file() {
+            if let Ok(metadata) = path.metadata() {
+                size += path.file_name().unwrap_or(OsStr::new("")).len() as u64;
+                size += metadata.len();
+            }
+        }
+    }
+    size
+}
+
+pub fn get_designed_storage(user_id: Uuid) -> String {
+    let user_dir = Path::new(&get_directory())
+        .join("users")
+        .join(user_id.to_string());
+    design_byte(get_directory_size(&user_dir))
+}
+
+pub fn design_byte(bytes: u64) -> String {
+    let mut hr_size = format!("{:.2}B", bytes as f64);
+    let k = bytes as f64 / 1024.0;
+    let m = k / 1024.0;
+    let g = m / 1024.0;
+    let t = g / 1024.0;
+
+    if t >= 1.0 {
+        hr_size = format!("{:.2}TB", t);
+    } else if g >= 1.0 {
+        hr_size = format!("{:.2}GB", g);
+    } else if m >= 1.0 {
+        hr_size = format!("{:.2}MB", m);
+    } else if k >= 1.0 {
+        hr_size = format!("{:.2}KB", k);
+    }
+    hr_size
+}
+
+pub fn get_used_ram() -> String {
+    let mut sys = System::new_all();
+    sys.refresh_all();
+    let used = sys.used_memory() * 1024; // kB to bytes
+    let total = sys.total_memory() * 1024;
+    format!("{}/{}", design_byte(used), design_byte(total))
+}
+
+// Helper to download the zip file content to a file on disk
+async fn download_zip(url: &str, as_name: &Path) -> Result<(), Box<dyn std::error::Error>> {
+    let response = reqwest::get(url).await?;
+
+    // Check for successful response status
+    if !response.status().is_success() {
+        return Err(format!("Failed to download file: Status {}", response.status()).into());
+    }
+
+    let mut zip_file = File::create(as_name)?;
+    let body = response.bytes().await?;
+    io::copy(&mut &*body, &mut zip_file)?;
+
+    Ok(())
+}
+
+fn extract_zip_contents_to_folder(
+    zip_path: &Path,
+    target_dir: &Path,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let file = File::open(zip_path)?;
+    let mut archive = ZipArchive::new(file)?;
+
+    let staging_dir = target_dir.with_extension("staging");
+
+    let _ = fs::remove_dir_all(&staging_dir);
+    fs::create_dir_all(&staging_dir)?;
+
+    let mut first_item_name: Option<PathBuf> = None;
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i)?;
+        let entry_path = staging_dir.join(file.sanitized_name());
+
+        if i == 0 {
+            if file.name().ends_with('/') || file.sanitized_name().components().count() == 1 {
+                first_item_name = Some(file.sanitized_name());
+            }
+        }
+
+        if file.name().ends_with('/') {
+            fs::create_dir_all(&entry_path)?;
+        } else {
+            if let Some(parent) = entry_path.parent() {
+                fs::create_dir_all(parent)?;
+            }
+            let mut out_file = File::create(entry_path)?;
+            io::copy(&mut file, &mut out_file)?;
+        }
+    }
+
+    if let Some(root_path) = first_item_name {
+        let root_dir = staging_dir.join(&root_path);
+
+        if root_dir.is_dir() {
+            let root_contents_count = fs::read_dir(&staging_dir)?.count();
+
+            if root_contents_count == 1
+                || (root_contents_count > 1 && fs::metadata(&root_dir).is_ok())
+            {
+                let _ = fs::remove_dir_all(target_dir);
+                fs::create_dir_all(target_dir)?;
+
+                for entry in fs::read_dir(root_dir)? {
+                    let entry = entry?;
+                    let src = entry.path();
+                    let dest = target_dir.join(entry.file_name());
+
+                    if let Err(_) = fs::rename(&src, &dest) {
+                        if src.is_file() {
+                            fs::copy(&src, &dest)?;
+                        } else {
+                            if entry.path().is_dir() {
+                                fs::rename(&src, &dest)?;
+                            }
+                        }
+                    }
+                }
+
+                let _ = fs::remove_dir_all(&staging_dir);
+                return Ok(());
+            }
+        }
+    }
+
+    log!("Extracting directly (no single root folder detected).");
+    let _ = fs::remove_dir_all(target_dir);
+    fs::rename(&staging_dir, target_dir)?;
+
+    Ok(())
+}
+
+pub async fn download_and_extract_zip(url: &str, as_name: &str) {
+    let base_dir = PathBuf::from(get_directory());
+    let zip_filename = format!("{}.zip", Uuid::new_v4()); // Use a unique name for the downloaded ZIP file
+    let zip_path = base_dir.join(&zip_filename);
+    let target_dir = base_dir.join(as_name);
+
+    // Step 1: Download the ZIP file
+    if let Err(e) = download_zip(url, &zip_path).await {
+        log!("Error downloading file: {}", e);
+        return;
+    }
+
+    // Step 2: Extract and flatten the ZIP file contents into the target directory
+    if let Err(e) = extract_zip_contents_to_folder(&zip_path, &target_dir) {
+        log!("Error extracting ZIP file contents: {}", e);
+    }
+
+    // Step 3: Clean up the downloaded ZIP file
+    if let Err(e) = fs::remove_file(&zip_path) {
+        log!("Error cleaning up ZIP file {}: {}", zip_path.display(), e);
+    }
+}

src/util/logger.rs

@@ -0,0 +1,135 @@
+use std::{
+    fs::{self, OpenOptions},
+    io::Write,
+    path::Path,
+    sync::{OnceLock, mpsc},
+    thread,
+    time::{SystemTime, UNIX_EPOCH},
+};
+static LOGGER: OnceLock<mpsc::Sender<LogMessage>> = OnceLock::new();
+
+struct LogMessage {
+    timestamp_ms: u128,
+    sender: Option<i64>,
+    message: String,
+}
+
+/// Initialize logger (call once)
+pub fn startup() {
+    let (tx, rx) = mpsc::channel::<LogMessage>();
+
+    LOGGER.set(tx).expect("Logger already initialized");
+
+    thread::spawn(move || {
+        // Prepare log directory
+        let log_dir = Path::new("logs");
+        fs::create_dir_all(log_dir).expect("Failed to create log directory");
+
+        let start_ts = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs();
+
+        let path = log_dir.join(format!("log_{}.txt", start_ts));
+
+        let mut file = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(path)
+            .expect("Failed to open log file");
+
+        // Dedicated logging loop
+        for msg in rx {
+            let timestamp_box = fixed_box(&msg.timestamp_ms.to_string(), 13);
+
+            let sender_box = match msg.sender {
+                Some(id) => fixed_box(&format!("{}", id), 19),
+                None => fixed_box("", 19),
+            };
+
+            let line = format!("{} {} {}", timestamp_box, sender_box, msg.message);
+
+            println!("{}", line);
+            let _ = writeln!(file, "{}", line);
+        }
+    });
+}
+fn fixed_box(content: &str, width: usize) -> String {
+    let s = content.chars().take(width).collect::<String>();
+    let len = s.chars().count();
+    if len < width {
+        let mut a = " ".repeat(width - len);
+        a.push_str(&s);
+        format!("[{}]", a)
+    } else {
+        s
+    }
+}
+/// Internal function (sync + async safe)
+pub fn log_internal(sender: Option<i64>, message: String) {
+    if let Some(tx) = LOGGER.get() {
+        let _ = tx.send(LogMessage {
+            timestamp_ms: SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap()
+                .as_millis(),
+            sender,
+            message,
+        });
+    } else {
+        println!("{}", message);
+    }
+}
+
+#[macro_export]
+macro_rules! log {
+    ($($arg:tt)*) => {
+        $crate::util::logger::log_internal(None, format!($($arg)*))
+    };
+}
+
+#[macro_export]
+macro_rules! log_from {
+    ($sender:expr, $($arg:tt)*) => {
+        $crate::util::logger::log_internal(Some($sender), format!($($arg)*))
+    };
+}
+#[macro_export]
+macro_rules! log_in {
+    ($($arg:tt)*) => {
+        $crate::util::logger::log_internal(
+            None,
+            format!("> {}", format!($($arg)*))
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! log_out {
+    ($($arg:tt)*) => {
+        $crate::util::logger::log_internal(
+            None,
+            format!("< {}", format!($($arg)*))
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! log_in_from {
+    ($sender:expr, $($arg:tt)*) => {
+        $crate::util::logger::log_internal(
+            Some($sender),
+            format!("> {}", format!($($arg)*))
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! log_out_from {
+    ($sender:expr, $($arg:tt)*) => {
+        $crate::util::logger::log_internal(
+            Some($sender),
+            format!("< {}", format!($($arg)*))
+        )
+    };
+}

src/util/mod.rs

@@ -0,0 +1,3 @@
+pub mod crypto_helper;
+pub mod file_util;
+pub mod logger;