Add encrypt/decrypt files, refactoring

Author: aelmizeb

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_crypt"
-version = "0.1.0"
+version = "1.0.0"
 authors = ["Abdellatif EL MIZEB <[email protected]>"]
 edition = "2021"
 include = ["LICENSE", "**/*.rs", "Cargo.toml"]
@@ -25,6 +25,7 @@ log = "0.4.27"
 # You only need serde if you want app persistence:
 serde = { version = "1.0.219", features = ["derive"] }
 chrono = "0.4.41"
+rfd = "0.15.3"
 
 # native:
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

Cargo.toml

@@ -1,12 +1,9 @@
 use eframe::egui;
 
 mod views;
+mod encryption;
 
-#[derive(serde::Deserialize, serde::Serialize, PartialEq)]
-pub enum EncryptionMethod {
-    Caesar,
-    XOR,
-}
+use encryption::{EncryptionMethod};
 
 use views::{
     decrypt_file::decrypt_file_view,
@@ -134,8 +131,8 @@ impl eframe::App for TemplateApp {
             match self.current_view {
                 CurrentView::EncryptText => encrypt_text_view(ui, self),
                 CurrentView::DecryptText => decrypt_text_view(ui, self),
-                CurrentView::EncryptFile => encrypt_file_view(ui),
-                CurrentView::DecryptFile => decrypt_file_view(ui),
+                CurrentView::EncryptFile => encrypt_file_view(ui, self),
+                CurrentView::DecryptFile => decrypt_file_view(ui, self),
                 CurrentView::About => about_view(ui),
                 CurrentView::Settings => settings_view(ui),
             }

src/app.rs

@@ -0,0 +1,33 @@
+pub fn caesar_decrypt(text: &str, key: &str) -> String {
+    let shift = key.len() as u8 % 26;
+    text.chars()
+        .map(|c| {
+            if c.is_ascii_lowercase() {
+                (((26 + c as u8 - b'a' - shift) % 26) + b'a') as char
+            } else if c.is_ascii_uppercase() {
+                (((26 + c as u8 - b'A' - shift) % 26) + b'A') as char
+            } else {
+                c
+            }
+        })
+        .collect()
+}
+
+pub fn caesar_encrypt(text: &str, key: &str) -> String {
+    let shift = key.len() as u8 % 26;
+    text.chars()
+        .map(|c| {
+            if c.is_ascii_lowercase() {
+                (((c as u8 - b'a' + shift) % 26) + b'a') as char
+            } else if c.is_ascii_uppercase() {
+                (((c as u8 - b'A' + shift) % 26) + b'A') as char
+            } else {
+                c
+            }
+        })
+        .collect()
+}
+
+pub fn caesar_encrypt_file(input: &str, key: &str) -> String {
+    caesar_encrypt(input, key)
+}

src/app/encryption/caesar.rs

@@ -0,0 +1,13 @@
+pub mod caesar;
+pub mod xor;
+
+pub use caesar::{caesar_encrypt, caesar_decrypt, caesar_encrypt_file};
+pub use xor::{xor_encrypt, xor_decrypt, xor_encrypt_file};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub enum EncryptionMethod {
+    Caesar,
+    XOR,
+}

src/app/encryption/mod.rs

@@ -0,0 +1,35 @@
+pub fn xor_decrypt(hex: &str, key: &str) -> String {
+    if key.is_empty() {
+        return "Error: key is empty".to_owned();
+    }
+
+    let key_bytes = key.as_bytes();
+    let bytes = (0..hex.len())
+        .step_by(2)
+        .filter_map(|i| u8::from_str_radix(&hex[i..i + 2], 16).ok())
+        .collect::<Vec<u8>>();
+
+    bytes
+        .iter()
+        .enumerate()
+        .map(|(i, &b)| b ^ key_bytes[i % key_bytes.len()])
+        .map(|b| b as char)
+        .collect()
+}
+
+pub fn xor_encrypt(text: &str, key: &str) -> String {
+    if key.is_empty() {
+        return "Error: key is empty".to_owned();
+    }
+    let key_bytes = key.as_bytes();
+    text.as_bytes()
+        .iter()
+        .enumerate()
+        .map(|(i, &b)| b ^ key_bytes[i % key_bytes.len()])
+        .map(|b| format!("{:02x}", b))
+        .collect()
+}
+
+pub fn xor_encrypt_file(input: &str, key: &str) -> String {
+    xor_encrypt(input, key)
+}

src/app/encryption/xor.rs

@@ -1,6 +1,54 @@
-use egui::Ui;
+use crate::app::{encryption, TemplateApp};
+use egui::{Ui, ComboBox};
+use rfd::FileDialog;
+use std::fs;
+use encryption::{EncryptionMethod, caesar_decrypt, xor_decrypt};
 
-pub fn decrypt_file_view(ui: &mut Ui) {
+pub fn decrypt_file_view(ui: &mut Ui, app: &mut TemplateApp) {
     ui.label("📂 Decrypt File");
-    ui.label("Feature coming soon: allow user to select a file, then decrypt it.");
+
+    ui.horizontal(|ui| {
+        ui.label("Encryption Key:");
+        ui.text_edit_singleline(&mut app.encryption_key);
+    });
+
+    ui.horizontal(|ui| {
+        ui.label("Encryption Method");
+        ComboBox::from_id_salt("file_decryption_method_select")
+            .selected_text(match app.selected_encryption {
+                EncryptionMethod::Caesar => "Caesar Cipher",
+                EncryptionMethod::XOR => "XOR Cipher",
+            })
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut app.selected_encryption, EncryptionMethod::Caesar, "Caesar Cipher");
+                ui.selectable_value(&mut app.selected_encryption, EncryptionMethod::XOR, "XOR Cipher");
+            });
+    });
+
+    if ui.button("Select File to Decrypt").clicked() {
+        if let Some(path) = FileDialog::new().pick_file() {
+            if let Ok(data) = fs::read_to_string(&path) {
+                let decrypted = match app.selected_encryption {
+                    EncryptionMethod::Caesar => caesar_decrypt(&data, &app.encryption_key),
+                    EncryptionMethod::XOR => xor_decrypt(&data, &app.encryption_key),
+                };
+
+                let output_path = path.with_file_name(format!(
+                    "decrypted_{}",
+                    path.file_name().unwrap().to_string_lossy()
+                ));
+
+                if let Err(err) = fs::write(&output_path, decrypted) {
+                    app.output_text = format!("Failed to write output: {}", err);
+                } else {
+                    app.output_text = format!("Decryption successful. Saved to:\n{}", output_path.display());
+                }
+            } else {
+                app.output_text = "Failed to read the selected file.".to_owned();
+            }
+        }
+    }
+
+    ui.label("Status:");
+    ui.text_edit_multiline(&mut app.output_text);
 }

src/app/views/decrypt_file.rs

@@ -1,5 +1,6 @@
-use crate::app::{TemplateApp, EncryptionMethod};
+use crate::app::{encryption, TemplateApp};
 use egui::{Ui, ComboBox};
+use encryption::{EncryptionMethod, caesar_decrypt, xor_decrypt};
 
 pub fn decrypt_text_view(ui: &mut Ui, app: &mut TemplateApp) {
     ui.label("🔓 Decrypt Text");
@@ -35,39 +36,3 @@ pub fn decrypt_text_view(ui: &mut Ui, app: &mut TemplateApp) {
     ui.label("Output:");
     ui.text_edit_multiline(&mut app.output_text);
 }
-
-// Simple Caesar cipher decryption (reverse of encryption)
-fn caesar_decrypt(text: &str, key: &str) -> String {
-    let shift = key.len() as u8 % 26;
-    text.chars()
-        .map(|c| {
-            if c.is_ascii_lowercase() {
-                (((26 + c as u8 - b'a' - shift) % 26) + b'a') as char
-            } else if c.is_ascii_uppercase() {
-                (((26 + c as u8 - b'A' - shift) % 26) + b'A') as char
-            } else {
-                c
-            }
-        })
-        .collect()
-}
-
-// XOR cipher decryption from hex input
-fn xor_decrypt(hex: &str, key: &str) -> String {
-    if key.is_empty() {
-        return "Error: key is empty".to_owned();
-    }
-
-    let key_bytes = key.as_bytes();
-    let bytes = (0..hex.len())
-        .step_by(2)
-        .filter_map(|i| u8::from_str_radix(&hex[i..i + 2], 16).ok())
-        .collect::<Vec<u8>>();
-
-    bytes
-        .iter()
-        .enumerate()
-        .map(|(i, &b)| b ^ key_bytes[i % key_bytes.len()])
-        .map(|b| b as char)
-        .collect()
-}

src/app/views/decrypt_text.rs

@@ -1,6 +1,54 @@
-use egui::Ui;
+use crate::app::{encryption, TemplateApp};
+use egui::{Ui, ComboBox};
+use rfd::FileDialog;
+use std::fs;
+use encryption::{EncryptionMethod, caesar_encrypt_file, xor_encrypt_file};
 
-pub fn encrypt_file_view(ui: &mut Ui) {
+pub fn encrypt_file_view(ui: &mut Ui, app: &mut TemplateApp) {
     ui.label("📁 Encrypt File");
-    ui.label("Feature coming soon: allow user to select a file, then encrypt it.");
+
+    ui.horizontal(|ui| {
+        ui.label("Encryption Key:");
+        ui.text_edit_singleline(&mut app.encryption_key);
+    });
+
+    ui.horizontal(|ui| {
+        ui.label("Encryption Method");
+        ComboBox::from_id_salt("file_encryption_method_select")
+            .selected_text(match app.selected_encryption {
+                EncryptionMethod::Caesar => "Caesar Cipher",
+                EncryptionMethod::XOR => "XOR Cipher",
+            })
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut app.selected_encryption, EncryptionMethod::Caesar, "Caesar Cipher");
+                ui.selectable_value(&mut app.selected_encryption, EncryptionMethod::XOR, "XOR Cipher");
+            });
+    });
+
+    if ui.button("Select File to Encrypt").clicked() {
+        if let Some(path) = FileDialog::new().pick_file() {
+            if let Ok(data) = fs::read_to_string(&path) {
+                let encrypted = match app.selected_encryption {
+                    EncryptionMethod::Caesar => caesar_encrypt_file(&data, &app.encryption_key),
+                    EncryptionMethod::XOR => xor_encrypt_file(&data, &app.encryption_key),
+                };
+
+                let output_path = path.with_file_name(format!(
+                    "encrypted_{}",
+                    path.file_name().unwrap().to_string_lossy()
+                ));
+
+                if let Err(err) = fs::write(&output_path, encrypted) {
+                    app.output_text = format!("Failed to write output: {}", err);
+                } else {
+                    app.output_text = format!("Encryption successful. Saved to:\n{}", output_path.display());
+                }
+            } else {
+                app.output_text = "Failed to read the selected file.".to_owned();
+            }
+        }
+    }
+
+    ui.label("Status:");
+    ui.text_edit_multiline(&mut app.output_text);
 }

src/app/views/encrypt_file.rs

@@ -1,5 +1,6 @@
-use crate::app::{TemplateApp, EncryptionMethod};
+use crate::app::{encryption, TemplateApp};
 use egui::{Ui, ComboBox};
+use encryption::{EncryptionMethod, caesar_encrypt, xor_encrypt};
 
 pub fn encrypt_text_view(ui: &mut Ui, app: &mut TemplateApp) {
     ui.label("🔒 Encrypt Text");
@@ -33,34 +34,4 @@ pub fn encrypt_text_view(ui: &mut Ui, app: &mut TemplateApp) {
 
     ui.label("Output:");
     ui.text_edit_multiline(&mut app.output_text);
-}
-
-// Simple Caesar cipher encryption shifting letters by key length (mod 26)
-fn caesar_encrypt(text: &str, key: &str) -> String {
-    let shift = key.len() as u8 % 26;
-    text.chars()
-        .map(|c| {
-            if c.is_ascii_lowercase() {
-                (((c as u8 - b'a' + shift) % 26) + b'a') as char
-            } else if c.is_ascii_uppercase() {
-                (((c as u8 - b'A' + shift) % 26) + b'A') as char
-            } else {
-                c
-            }
-        })
-        .collect()
-}
-
-// XOR cipher encryption with repeating key bytes (output as hex string)
-fn xor_encrypt(text: &str, key: &str) -> String {
-    if key.is_empty() {
-        return "Error: key is empty".to_owned();
-    }
-    let key_bytes = key.as_bytes();
-    text.as_bytes()
-        .iter()
-        .enumerate()
-        .map(|(i, &b)| b ^ key_bytes[i % key_bytes.len()])
-        .map(|b| format!("{:02x}", b))
-        .collect()
-}
+}