Merge branch 'dev' for release 1.2.5

Author: XenorInspire

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "worgen_x"
-version = "1.2.4"
+version = "1.2.5"
 edition = "2024"
 authors = ["Xen0rInspire"]
 license = "GNU General Public License v3.0"
@@ -15,12 +15,12 @@ cli = ["serde_json", "clap"]
 gui = []
 
 [dependencies]
-rand = { version = "0.9.1", features = ["thread_rng"], default-features = false }
-thiserror = { version = "2.0.12", default-features = false }
+rand = { version = "0.9.2", features = ["thread_rng"], default-features = false }
+thiserror = { version = "2.0.17", default-features = false }
 num_cpus = { version = "1.17.0", default-features = false }
-serde_json = { version = "1.0.140", optional = true, features = ["std"], default-features = false }
-indicatif = { version = "0.17.11", default-features = false }
-clap = { version = "4.5.40", optional = true, features = ["std"], default-features = false }
+serde_json = { version = "1.0.145", optional = true, features = ["std"], default-features = false }
+indicatif = { version = "0.18.0", default-features = false }
+clap = { version = "4.5.48", optional = true, features = ["std"], default-features = false }
 hex = { version = "0.4.3", features = ["alloc"], default-features = false }
 md-5 = { version = "0.10.6", default-features = false }
 sha-1 = { version = "0.10.1", default-features = false }

Cargo.toml

@@ -65,7 +65,7 @@ pub fn load_cpu_benchmark(nb_of_threads: usize) -> Result<u64, WorgenXError> {
     for _ in 0..nb_of_threads {
         let shared_signal_rst: Arc<AtomicBool> = Arc::clone(&shared_signal);
         threads.push(thread::spawn(move || {
-            run_stress_test(&shared_signal_rst).unwrap_or_else(|e| println!("{}", e));
+            run_stress_test(&shared_signal_rst).unwrap_or_else(|e| println!("{e}"));
         }));
     }
 

src/benchmark.rs

@@ -28,7 +28,7 @@ fn main() {
 
     #[cfg(feature = "cli")]
     if let Err(e) =  mode::cli::run() {
-        eprintln!("{}", e);
+        eprintln!("{e}");
         std::process::exit(1);
     }
 

src/main.rs

@@ -46,6 +46,7 @@ struct BenchmarkOptions {
 ///
 /// Command struct containing the different features of WorgenX.
 ///
+#[allow(clippy::too_many_lines)]
 fn build_command_context() -> Command {
     let default_threads: &'static str = Box::leak(num_cpus::get().to_string().into_boxed_str()); // Ensure a static reference to the number of logical cores of the CPU
     let wordlist_command: Command = Command::new("wordlist")
@@ -274,7 +275,7 @@ fn run_passwd(sub_matches: &ArgMatches) -> Result<(), WorgenXError> {
     };
 
     if !password_generation_parameters.no_display {
-        println!("{}", all_passwords);
+        println!("{all_passwords}");
     }
 
     if !password_generation_parameters.output_file.is_empty() {
@@ -375,7 +376,13 @@ fn run_wordlist(sub_matches: &ArgMatches) -> Result<(), WorgenXError> {
 
     let wordlist_config: WordlistConfig = wordlist::build_wordlist_config(&wordlist_generation_parameters.wordlist_values);
     let nb_of_passwords: u64 = wordlist_config.dict.len().pow(wordlist_config.mask_indexes.len() as u32) as u64;
-    println!("Estimated size of the wordlist: {}", system::get_estimated_size(nb_of_passwords, wordlist_config.formated_mask.len() as u64));
+    let len_of_string: u64 = if wordlist_config.hash.is_empty() { 
+        wordlist_config.formated_mask.len() as u64
+    } else { 
+        system::get_size_of_hash(&wordlist_config.hash) as u64
+    };
+
+    println!("Estimated size of the wordlist: {}", system::get_estimated_size(nb_of_passwords, len_of_string));
     println!("Wordlist generation in progress...");
 
     wordlist::wordlist_generation_scheduler(
@@ -454,7 +461,7 @@ fn run_benchmark(sub_matches: &ArgMatches) -> Result<(), WorgenXError> {
     let benchmark_parameters: BenchmarkOptions = allocate_benchmark_config_cli(sub_matches);
     let result: u64 = benchmark::load_cpu_benchmark(benchmark_parameters.threads)?;
 
-    println!("Your CPU has generated {} passwords in 1 minute", result);
+    println!("Your CPU has generated {result} passwords in 1 minute");
     Ok(())
 }
 

src/mode/cli.rs

@@ -104,7 +104,7 @@ fn main_passwd_generation() {
             while let Err(e) =
                 system::save_passwd_to_file(&Arc::clone(&shared_file), &passwords.join("\n"))
             {
-                println!("\n{}", e);
+                println!("\n{e}");
                 println!("Do you want to try again ? (y/n)");
                 let choice: String = system::get_user_choice_yn();
                 if choice.eq("n") {
@@ -192,10 +192,13 @@ fn main_wordlist_generation() {
             .len()
             .pow(wordlist_config.mask_indexes.len() as u32)
             as u64;
-        println!(
-            "Estimated size of the wordlist: {}",
-            system::get_estimated_size(nb_of_passwords, wordlist_config.formated_mask.len() as u64)
-        );
+
+        let len_of_string: u64 = if wordlist_config.hash.is_empty() { 
+            wordlist_config.formated_mask.len() as u64
+        } else { 
+            system::get_size_of_hash(&wordlist_config.hash) as u64
+        };
+        println!("Estimated size of the wordlist: {}", system::get_estimated_size(nb_of_passwords, len_of_string));
         println!("Do you want to continue ? (y/n)");
         if system::get_user_choice_yn().eq("n") {
             return;
@@ -220,11 +223,11 @@ fn main_wordlist_generation() {
             &filename,
             false,
         ) {
-            println!("{}", e);
+            println!("{e}");
             return;
         }
 
-        println!("The wordlist has been saved in the file : {}", filename);
+        println!("The wordlist has been saved in the file : {filename}");
         println!("\nDo you want to generate another wordlist ? (y/n)");
         again = system::get_user_choice_yn();
     }
@@ -319,8 +322,8 @@ fn main_benchmark() {
         println!("The benchmark will start in 5 seconds...");
         thread::sleep(std::time::Duration::from_secs(5));
         match benchmark::load_cpu_benchmark(num_cpus::get()) {
-            Ok(nb_of_passwords) => println!("Your CPU has generated {} passwords in 1 minute", nb_of_passwords),
-            Err(e) => println!("{}", e),
+            Ok(nb_of_passwords) => println!("Your CPU has generated {nb_of_passwords} passwords in 1 minute"),
+            Err(e) => println!("{e}"),
         }
 
         println!("\nDo you want to run a new benchmark ? (y/n)");
@@ -350,20 +353,20 @@ pub fn saving_procedure(target: &str) -> Result<(File, String), SystemError> {
 
     let filename: String = env::var(target::HOME_ENV_VAR).map_or_else(|_| {
         println!("Unable to get the home directory, the file will be saved in the current directory\n");
-        format!("./{}", filename)
+        format!("./{filename}")
     }, |home_path| {
-        let parent_folder: String = format!("{}{}", home_path, target);
+        let parent_folder: String = format!("{home_path}{target}");
         let parent_folder_created: String = match system::create_folder_if_not_exists(
             &parent_folder,
         ) {
-            Ok(()) => format!("{}{}", home_path, target),
+            Ok(()) => format!("{home_path}{target}"),
             Err(e) => {
-                println!("{}", e);
+                println!("{e}");
                 println!("Unable to create the folder, the file will be saved in the current directory");
-                format!("./{}", filename)
+                format!("./{filename}")
             }
         };
-        format!("{}{}", parent_folder_created, filename)
+        format!("{parent_folder_created}{filename}")
     });
 
     let file: File = match OpenOptions::new()
@@ -374,7 +377,7 @@ pub fn saving_procedure(target: &str) -> Result<(File, String), SystemError> {
     {
         Ok(file) => file,
         Err(e) => {
-            println!("{}", e);
+            println!("{e}");
             return Err(SystemError::UnableToCreateFile(filename, e.to_string()));
         }
     };

src/mode/gui.rs

@@ -10,6 +10,7 @@ use sha1::Sha1;
 use sha2::{Sha224, Sha256, Sha384, Sha512};
 use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
 use std::{
+    fmt::Write as WriteStr,
     fs::File,
     io::Write,
     path::Path,
@@ -105,7 +106,7 @@ where
                     println!("Please enter a valid number greater than 0");
                 }
             }
-            Err(e) => println!("Please enter a valid number greater than 0, {}", e),
+            Err(e) => println!("Please enter a valid number greater than 0, {e}"),
         }
     }
 
@@ -283,7 +284,7 @@ pub fn save_passwd_to_file(file: &Arc<Mutex<File>>, passwords: &str) -> Result<(
         ))
     })?;
 
-    file.write_all(format!("{}\n", passwords).as_bytes())
+    file.write_all(format!("{passwords}\n").as_bytes())
         .map_err(|_| {
             WorgenXError::SystemError(SystemError::UnableToWriteToFile(
                 "output file".to_string(),
@@ -331,20 +332,20 @@ pub fn get_estimated_size(nb_of_passwords: u64, length: u64) -> String {
     let size: u64 = nb_of_passwords * (length + 1); // +1 for the newline character
     let mut size_str: String = String::new();
     if size < 1024 {
-        size_str.push_str(&size.to_string());
-        size_str.push_str(" bytes");
+        write!(size_str, "{size}").unwrap_or_default();
+        write!(size_str, " bytes").unwrap_or_default();
     } else if size < 1048576 {
-        size_str.push_str(&format!("{:.2}", size as f64 / 1024.0));
-        size_str.push_str(" KB");
+        write!(size_str, "{:.2}", size as f64 / 1024.0).unwrap_or_default();
+        write!(size_str, " KB").unwrap_or_default();
     } else if size < 1073741824 {
-        size_str.push_str(&format!("{:.2}", size as f64 / 1048576.0));
-        size_str.push_str(" MB");
+        write!(size_str, "{:.2}", size as f64 / 1048576.0).unwrap_or_default();
+        write!(size_str, " MB").unwrap_or_default();
     } else if size < 1099511627776 {
-        size_str.push_str(&format!("{:.2}", size as f64 / 1073741824.0));
-        size_str.push_str(" GB");
+        write!(size_str, "{:.2}", size as f64 / 1073741824.0).unwrap_or_default();
+        write!(size_str, " GB").unwrap_or_default();
     } else {
-        size_str.push_str(&format!("{:.2}", size as f64 / 1099511627776.0));
-        size_str.push_str(" TB");
+        write!(size_str, "{:.2}", size as f64 / 1099511627776.0).unwrap_or_default();
+        write!(size_str, " TB").unwrap_or_default();
     }
     size_str
 }
@@ -399,6 +400,36 @@ fn hash_with_digest<D: Digest>(mut hasher: D, password: &str) -> String {
     hex::encode(result)
 }
 
+/// This function returns the size of the hash in bytes for a given hash algorithm.
+/// It is used to determine the size of the hash in bytes.
+///
+/// # Arguments
+///
+/// * `hash` - The hash algorithm to check.
+///
+/// # Returns
+///
+/// The size of the hash in bytes. If the hash algorithm is not supported, it returns 0.
+///
+pub fn get_size_of_hash(hash: &str) -> usize {
+    match hash {
+        "md5" => 32,
+        "sha1" => 40,
+        "sha224" => 56,
+        "sha256" => 64,
+        "sha384" => 96,
+        "sha512" => 128,
+        "sha3-224" => 56,
+        "sha3-256" => 64,
+        "sha3-384" => 96,
+        "sha3-512" => 128,
+        "blake2b-512" => 128,
+        "blake2s-256" => 64,
+        "whirlpool" => 128,
+        _ => 0, // Unsupported hash algorithm.
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -509,4 +540,22 @@ mod tests {
         assert_eq!(manage_hash(password, "whirlpool").unwrap(), "74dfc2b27acfa364da55f93a5caee29ccad3557247eda238831b3e9bd931b01d77fe994e4f12b9d4cfa92a124461d2065197d8cf7f33fc88566da2db2a4d6eae");
         assert!(manage_hash(password, "sha999").is_err());
     }
+
+    #[test]
+    fn test_get_size_of_hash() {
+        assert_eq!(get_size_of_hash("md5"), 32);
+        assert_eq!(get_size_of_hash("sha1"), 40);
+        assert_eq!(get_size_of_hash("sha224"), 56);
+        assert_eq!(get_size_of_hash("sha256"), 64);
+        assert_eq!(get_size_of_hash("sha384"), 96);
+        assert_eq!(get_size_of_hash("sha512"), 128);
+        assert_eq!(get_size_of_hash("sha3-224"), 56);
+        assert_eq!(get_size_of_hash("sha3-256"), 64);
+        assert_eq!(get_size_of_hash("sha3-384"), 96);
+        assert_eq!(get_size_of_hash("sha3-512"), 128);
+        assert_eq!(get_size_of_hash("blake2b-512"), 128);
+        assert_eq!(get_size_of_hash("blake2s-256"), 64);
+        assert_eq!(get_size_of_hash("whirlpool"), 128);
+        assert_eq!(get_size_of_hash("sha999"), 0); // Unsupported hash algorithm
+    }
 }

src/system.rs

@@ -191,7 +191,7 @@ pub fn wordlist_generation_scheduler(
             return Err(err.clone());
         }
 
-        return Err(WorgenXError::SystemError(SystemError::ThreadError(format!("{:?}", e))));
+        return Err(WorgenXError::SystemError(SystemError::ThreadError(format!("{e:?}"))));
     }
 
     println!("\nWordlist generated in {}", system::get_elapsed_time(start));
@@ -340,7 +340,7 @@ fn generate_wordlist_part(
             }
 
             if !found {
-                line.push(formated_mask[i])
+                line.push(formated_mask[i]);
             }
         });
         for idx in (0..dict_indexes.len()).rev() {