adding secure file vault

Author: mdabir1203

Module03/data_vault/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "data_vault"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+

Module03/data_vault/src/colors.rs

@@ -0,0 +1,156 @@
+// Reset and text styles
+pub const RESET: &str = "\x1b[0m";
+pub const BOLD: &str = "\x1b[1m";
+
+// Tailwind CSS Colors: Gray
+pub const GRAY50: &str = "\x1b[38;2;249;250;251m";
+pub const GRAY100: &str = "\x1b[38;2;243;244;246m";
+pub const GRAY200: &str = "\x1b[38;2;229;231;235m";
+pub const GRAY300: &str = "\x1b[38;2;209;213;219m";
+pub const GRAY400: &str = "\x1b[38;2;156;163;175m";
+pub const GRAY500: &str = "\x1b[38;2;107;114;128m";
+pub const GRAY600: &str = "\x1b[38;2;75;85;99m";
+pub const GRAY700: &str = "\x1b[38;2;55;65;81m";
+pub const GRAY800: &str = "\x1b[38;2;31;41;55m";
+pub const GRAY900: &str = "\x1b[38;2;17;24;39m";
+
+// Tailwind CSS Colors: Red
+pub const RED50: &str = "\x1b[38;2;254;242;242m";
+pub const RED100: &str = "\x1b[38;2;254;226;226m";
+pub const RED200: &str = "\x1b[38;2;254;202;202m";
+pub const RED300: &str = "\x1b[38;2;252;165;165m";
+pub const RED400: &str = "\x1b[38;2;248;113;113m";
+pub const RED500: &str = "\x1b[38;2;239;68;68m";
+pub const RED600: &str = "\x1b[38;2;220;38;38m";
+pub const RED700: &str = "\x1b[38;2;185;28;28m";
+pub const RED800: &str = "\x1b[38;2;153;27;27m";
+pub const RED900: &str = "\x1b[38;2;127;29;29m";
+
+// Tailwind CSS Colors: Yellow
+pub const YELLOW50: &str = "\x1b[38;2;255;251;235m";
+pub const YELLOW100: &str = "\x1b[38;2;254;243;199m";
+pub const YELLOW200: &str = "\x1b[38;2;253;230;138m";
+pub const YELLOW300: &str = "\x1b[38;2;252;211;77m";
+pub const YELLOW400: &str = "\x1b[38;2;251;191;36m";
+pub const YELLOW500: &str = "\x1b[38;2;245;158;11m";
+pub const YELLOW600: &str = "\x1b[38;2;217;119;6m";
+pub const YELLOW700: &str = "\x1b[38;2;180;83;9m";
+pub const YELLOW800: &str = "\x1b[38;2;146;64;14m";
+pub const YELLOW900: &str = "\x1b[38;2;120;53;15m";
+
+// Tailwind CSS Colors: Green
+pub const GREEN50: &str = "\x1b[38;2;240;253;244m";
+pub const GREEN100: &str = "\x1b[38;2;220;252;231m";
+pub const GREEN200: &str = "\x1b[38;2;187;247;208m";
+pub const GREEN300: &str = "\x1b[38;2;134;239;172m";
+pub const GREEN400: &str = "\x1b[38;2;74;222;128m";
+pub const GREEN500: &str = "\x1b[38;2;34;197;94m";
+pub const GREEN600: &str = "\x1b[38;2;22;163;74m";
+pub const GREEN700: &str = "\x1b[38;2;21;128;61m";
+pub const GREEN800: &str = "\x1b[38;2;22;101;52m";
+pub const GREEN900: &str = "\x1b[38;2;20;83;45m";
+
+// Tailwind CSS Colors: Blue
+pub const BLUE50: &str = "\x1b[38;2;239;246;255m";
+pub const BLUE100: &str = "\x1b[38;2;219;234;254m";
+pub const BLUE200: &str = "\x1b[38;2;191;219;254m";
+pub const BLUE300: &str = "\x1b[38;2;147;197;253m";
+pub const BLUE400: &str = "\x1b[38;2;96;165;250m";
+pub const BLUE500: &str = "\x1b[38;2;59;130;246m";
+pub const BLUE600: &str = "\x1b[38;2;37;99;235m";
+pub const BLUE700: &str = "\x1b[38;2;29;78;216m";
+pub const BLUE800: &str = "\x1b[38;2;30;64;175m";
+pub const BLUE900: &str = "\x1b[38;2;30;58;138m";
+
+// Tailwind CSS Colors: Indigo
+pub const INDIGO50: &str = "\x1b[38;2;238;242;255m";
+pub const INDIGO100: &str = "\x1b[38;2;224;231;255m";
+pub const INDIGO200: &str = "\x1b[38;2;199;210;254m";
+pub const INDIGO300: &str = "\x1b[38;2;165;180;252m";
+pub const INDIGO400: &str = "\x1b[38;2;129;140;248m";
+pub const INDIGO500: &str = "\x1b[38;2;99;102;241m";
+pub const INDIGO600: &str = "\x1b[38;2;79;70;229m";
+pub const INDIGO700: &str = "\x1b[38;2;67;56;202m";
+pub const INDIGO800: &str = "\x1b[38;2;55;48;163m";
+pub const INDIGO900: &str = "\x1b[38;2;49;46;129m";
+
+// Tailwind CSS Colors: Purple
+pub const PURPLE50: &str = "\x1b[38;2;250;245;255m";
+pub const PURPLE100: &str = "\x1b[38;2;243;232;255m";
+pub const PURPLE200: &str = "\x1b[38;2;233;213;255m";
+pub const PURPLE300: &str = "\x1b[38;2;216;180;254m";
+pub const PURPLE400: &str = "\x1b[38;2;192;132;252m";
+pub const PURPLE500: &str = "\x1b[38;2;168;85;247m";
+pub const PURPLE600: &str = "\x1b[38;2;147;51;234m";
+pub const PURPLE700: &str = "\x1b[38;2;126;34;206m";
+pub const PURPLE800: &str = "\x1b[38;2;107;33;168m";
+pub const PURPLE900: &str = "\x1b[38;2;88;28;135m";
+
+
+// Tailwind CSS Colors: Cyan
+pub const CYAN50: &str = "\x1b[38;2;236;254;255m";
+pub const CYAN100: &str = "\x1b[38;2;207;250;254m";
+pub const CYAN200: &str = "\x1b[38;2;165;243;252m";
+pub const CYAN300: &str = "\x1b[38;2;103;232;249m";
+pub const CYAN400: &str = "\x1b[38;2;34;211;238m";
+pub const CYAN500: &str = "\x1b[38;2;6;182;212m";
+pub const CYAN600: &str = "\x1b[38;2;8;145;178m";
+pub const CYAN700: &str = "\x1b[38;2;14;116;144m";
+pub const CYAN800: &str = "\x1b[38;2;21;94;117m";
+pub const CYAN900: &str = "\x1b[38;2;22;78;99m";
+
+// Tailwind CSS Colors: Teal
+pub const TEAL50: &str = "\x1b[38;2;240;253;250m";
+pub const TEAL100: &str = "\x1b[38;2;204;251;241m";
+pub const TEAL200: &str = "\x1b[38;2;153;246;228m";
+pub const TEAL300: &str = "\x1b[38;2;94;234;212m";
+pub const TEAL400: &str = "\x1b[38;2;45;212;191m";
+pub const TEAL500: &str = "\x1b[38;2;20;184;166m";
+pub const TEAL600: &str = "\x1b[38;2;13;148;136m";
+pub const TEAL700: &str = "\x1b[38;2;15;118;110m";
+pub const TEAL800: &str = "\x1b[38;2;17;94;89m";
+pub const TEAL900: &str = "\x1b[38;2;19;78;74m";
+
+// Tailwind CSS Colors: Emerald
+pub const EMERALD50: &str = "\x1b[38;2;236;253;245m";
+pub const EMERALD100: &str = "\x1b[38;2;209;250;229m";
+pub const EMERALD200: &str = "\x1b[38;2;167;243;208m";
+pub const EMERALD300: &str = "\x1b[38;2;110;231;183m";
+pub const EMERALD400: &str = "\x1b[38;2;52;211;153m";
+pub const EMERALD500: &str = "\x1b[38;2;16;185;129m";
+pub const EMERALD600: &str = "\x1b[38;2;5;150;105m";
+pub const EMERALD700: &str = "\x1b[38;2;4;120;87m";
+pub const EMERALD800: &str = "\x1b[38;2;6;95;70m";
+pub const EMERALD900: &str = "\x1b[38;2;6;78;59m";
+
+// Tailwind CSS Colors: Lime
+pub const LIME50: &str = "\x1b[38;2;247;254;231m";
+pub const LIME100: &str = "\x1b[38;2;236;252;203m";
+pub const LIME200: &str = "\x1b[38;2;217;249;157m";
+pub const LIME300: &str = "\x1b[38;2;190;242;100m";
+pub const LIME400: &str = "\x1b[38;2;163;230;53m";
+pub const LIME500: &str = "\x1b[38;2;132;204;22m";
+pub const LIME600: &str = "\x1b[38;2;101;163;13m";
+pub const LIME700: &str = "\x1b[38;2;77;124;15m";
+pub const LIME800: &str = "\x1b[38;2;63;98;18m";
+pub const LIME900: &str = "\x1b[38;2;54;83;20m";
+
+// Tailwind CSS Colors: Amber
+pub const AMBER50: &str = "\x1b[38;2;255;251;235m";
+pub const AMBER100: &str = "\x1b[38;2;254;243;199m";
+pub const AMBER200: &str = "\x1b[38;2;253;230;138m";
+pub const AMBER300: &str = "\x1b[38;2;252;211;77m";
+pub const AMBER400: &str = "\x1b[38;2;251;191;36m";
+pub const AMBER500: &str = "\x1b[38;2;245;158;11m";
+pub const AMBER600: &str = "\x1b[38;2;217;119;6m";
+pub const AMBER700: &str = "\x1b[38;2;180;83;9m";
+pub const AMBER800: &str = "\x1b[38;2;146;64;14m";
+pub const AMBER900: &str = "\x1b[38;2;120;53;15m";
+
+// Tailwind CSS Colors: Fuchsia
+pub const FUCHSIA50: &str = "\x1b[38;2;253;244;255m";
+pub const FUCHSIA100: &str = "\x1b[38;2;250;232;255m";
+pub const FUCHSIA200: &str = "\x1b[38;2;245;208;254m";
+pub const FUCHSIA300: &str = "\x1b[38;2;240;171;252m";
+pub const FUCHSIA400: &str = "\x1b[38;2;232;121;249m";
+pub const FUCHSIA500: &str = "\x1b[38;2;217;70;239m";

Module03/data_vault/src/main.rs

@@ -0,0 +1,61 @@
+use std::collections::HashMap;
+pub mod colors;
+
+// A structure to represent our key-value store
+struct SearchEngineKV {
+    store: HashMap<String, Vec<String>>,
+}
+
+impl SearchEngineKV {
+    // Create a new empty store
+    fn new() -> SearchEngineKV {
+        SearchEngineKV {
+            store: HashMap::new(),
+        }
+    }
+
+    // Insert a URL for a given keyword
+    fn insert(&mut self, key: String, value: String) {
+        self.store.entry(key).or_insert_with(Vec::new).push(value);
+    }
+
+    // Retrieve URLs for a given keyword
+    fn get(&self, key: &str) -> Option<&Vec<String>> {
+        self.store.get(key)
+    }
+
+    // Remove a URL from a keyword entry
+    fn remove_url(&mut self, key: &str, url: &str) {
+        if let Some(urls) = self.store.get_mut(key) {
+            urls.retain(|u| u != url);
+            if urls.is_empty() {
+                self.store.remove(key);
+            }
+        }
+    }
+}
+
+fn main() {
+    let mut engine = SearchEngineKV::new();
+
+    // Adding some sample data
+    engine.insert("Cplusplus".to_string(), "https://cplusplus.com/".to_string());
+    engine.insert("rust programming".to_string(), "https://doc.rust-lang.org".to_string());
+    engine.insert("web development".to_string(), "https://developer.mozilla.org".to_string());
+
+    // Retrieving data
+    if let Some(urls) = engine.get("rust programming") {
+        println!("URLs for 'rust programming': {:?}", urls);
+    }
+
+    // Removing a URL
+    engine.remove_url("web development", "https://developer.mozilla.org");
+    
+    // Check if URL was removed // fix the line below 
+    if let Some(urls) = engine.get("web development") {
+        println!("URLs for 'web development' after removal: {:?}", urls);
+    } else {
+        println!("No URLs found for 'web development' after removal");
+    }
+
+}

Module03/data_vault_ex/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "data_vault_ex"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

Module03/data_vault_ex/perf-6.9.0.tar.gz

@@ -0,0 +1,101 @@
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+
+// Define a result type for our operations
+type Result<T> = std::result::Result<T, String>;
+
+pub struct KeyValueStore {
+    store: Arc<RwLock<HashMap<String, String>>>,
+}
+
+impl KeyValueStore {
+    // Initialize a new KeyValueStore
+    pub fn new() -> Self {
+        KeyValueStore {
+            store: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    // Insert a key-value pair
+    pub fn insert(&self, key: String, value: String) -> Result<()> {
+        match self.store.write() {
+            Ok(mut guard) => {
+                guard.insert(key, value);
+                Ok(())
+            },
+            Err(e) => Err(format!("Failed to acquire write lock: {}", e)),
+        }
+    }
+
+    // Retrieve a value given a key
+    pub fn get(&self, key: &str) -> Result<Option<String>> {
+        match self.store.read() {
+            Ok(guard) => Ok(guard.get(key).cloned()),
+            Err(e) => Err(format!("Failed to acquire read lock: {}", e)),
+        }
+    }
+
+    // Remove a key-value pair
+    pub fn remove(&self, key: &str) -> Result<Option<String>> {
+        match self.store.write() {
+            Ok(mut guard) => Ok(guard.remove(key)),
+            Err(e) => Err(format!("Failed to acquire write lock: {}", e)),
+        }
+    }
+
+    // Example usage might include checking if a key exists
+    pub fn contains(&self, key: &str) -> Result<bool> {
+        self.get(key).map(|v| v.is_some())
+    }
+}
+
+// adding a main function to test the above key value store 
+
+fn main() {
+    // Initialize the key-value store
+    let store = KeyValueStore::new();
+
+    // Insert some key-value pairs
+    match store.insert("key1".to_string(), "value1".to_string()) {
+        Ok(_) => println!("Inserted key1 -> value1"),
+        Err(e) => println!("Error inserting key1: {}", e),
+    }
+
+    match store.insert("key2".to_string(), "value2".to_string()) {
+        Ok(_) => println!("Inserted key2 -> value2"),
+        Err(e) => println!("Error inserting key2: {}", e),
+    }
+
+    // Retrieve a value
+    match store.get("key1") {
+        Ok(Some(value)) => println!("Retrieved key1 -> {}", value),
+        Ok(None) => println!("key1 not found"),
+        Err(e) => println!("Error retrieving key1: {}", e),
+    }
+
+    // Check if a key exists
+    match store.contains("key2") {
+        Ok(true) => println!("key2 exists"),
+        Ok(false) => println!("key2 does not exist"),
+        Err(e) => println!("Error checking key2: {}", e),
+    }
+
+    // Remove a key-value pair
+    match store.remove("key1") {
+        Ok(Some(value)) => println!("Removed key1 -> {}", value),
+        Ok(None) => println!("key1 not found"),
+        Err(e) => println!("Error removing key1: {}", e),
+    }
+
+    // Try to retrieve the removed key
+    match store.get("key1") {
+        Ok(Some(value)) => println!("Retrieved key1 -> {}", value),
+        Ok(None) => println!("key1 not found"),
+        Err(e) => println!("Error retrieving key1: {}", e),
+    }
+}
+
+// Explanation of design choices:
+// - `Arc` (Atomic Reference Counting) with `RwLock` allows for shared ownership with safe concurrent access.
+// - Using `String` for both key and value for simplicity, but this could be generic in a real-world scenario.
+// - Error handling with `Result` allows for clear propagation of errors to the caller.

Module03/data_vault_ex/src/main.rs

@@ -0,0 +1,12 @@
+[package]
+name = "data_vault_exx"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+argon2 = "0.5.3"
+rand = "0.8.5"
+serde = { version = "1.0.209", features = ["derive"] }
+serde_json = "1.0.127"
+thiserror = "1.0.63"
+

Module03/data_vault_exx/Cargo.toml

@@ -0,0 +1,11 @@
+pub mod reader {
+    use std::fs::File;
+    use std::io::Read;
+    use zip::ZipArchive;
+
+    pub fn read_zip(filename: &str) -> Result<ZipArchive<std::fs::File>, zip::result::ZipError> {
+        let file = File::open(filename)?;
+        let archive = ZipArchive::new(file)?;
+        Ok(archive)
+    }
+}

Module03/zip_cracker/src/reader.rs

@@ -0,0 +1,6 @@
+[package]
+name = "cachecomponent"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

Module05/cachecomponent/Cargo.toml

@@ -0,0 +1,18 @@
+The `GetCache` trait and its implementations for `InMemoryCache` and ``Cache`` structs provide a flexible and modular caching system.
+
+Here are some scenarios where such reusable modular components can be useful:
+
+### 1. Web Applications
+In web development, caching is often used to improve performance by reducing the number of database queries or computationally expensive operations. Your caching system can be used in web frameworks like Rocket or actix-web to cache frequently accessed data, such as user sessions, configuration data, or intermediate computation results.
+
+### 2. Distributed Systems
+In distributed systems, caching can help reduce the load on shared resources and improve overall system performance. Your caching system can be used in distributed systems built with frameworks like Tokio or async-std to cache data that's frequently accessed across multiple nodes.
+
+### 3. Machine Learning and Data Science
+In machine learning and data science applications, caching can be used to store intermediate results of computationally expensive operations, such as data preprocessing or model training. Your caching system can be used in Rust libraries like rusty-machine or rusty-nn to cache intermediate results and improve performance.
+
+### 4. Embedded Systems
+In embedded systems, caching can be used to improve performance and reduce memory usage. Your caching system can be used in embedded systems built with Rust to cache frequently accessed data, such as sensor readings or configuration data.
+
+### 5. Game Development
+In game development, caching can be used to improve performance by reducing the number of computations required for game logic or physics simulations. Your caching system can be used in game engines like Piston or ggez to cache intermediate results and improve performance.