Merge branch 'dev' for release 1.2.0

Author: XenorInspire

Cargo.toml

@@ -1,19 +1,31 @@
 [package]
 name = "worgen_x"
-version = "1.1.1"
+version = "1.2.0"
 edition = "2021"
 authors = ["Xen0rInspire"]
 license = "GNU General Public License v3.0"
+repository = "https://github.com/XenorInspire/WorgenX"
+homepage = "https://github.com/XenorInspire/WorgenX"
+keywords = ["password", "cracking", "wordlist", "entropy", "random", "generator"]
+readme = "README.md"
 description = "A powerful command line tool to generate relevant wordlists for password cracking. It can also generate random passwords with a good entropy."
 
 [features]
 cli = ["serde_json", "clap"]
 gui = []
 
 [dependencies]
-rand = "0.8.5"
-thiserror = "1.0.59"
+rand = { version = "0.8.5", features = ["getrandom"], default-features = false }
+thiserror = "1.0.61"
 num_cpus = "1.16.0"
-serde_json = { version = "1.0.116", optional = true }
-indicatif = "0.17.8"
-clap = { version = "4.5.4", optional = true }
+serde_json = { version = "1.0.120", optional = true, features = ["std"], default-features = false }
+indicatif = { version = "0.17.8", default-features = false }
+clap = { version = "4.5.9", optional = true, features = ["std"], default-features = false }
+md-5 = "0.10.6"
+sha-1 = "0.10.1"
+sha2 = "0.10.8"
+digest = "0.10.7"
+hex = "0.4.3"
+sha3 = "0.10.8"
+blake2 = "0.10.6"
+whirlpool = "0.10.4"

src/benchmark.rs

@@ -166,3 +166,14 @@ fn build_wordlist_progress_bar(seconds: u64, pb: &Arc<Mutex<ProgressBar>>) {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_load_cpu_benchmark() {
+        let result: Result<u64, WorgenXError> = load_cpu_benchmark(4);
+        assert!(result.is_ok());
+    }
+}

src/error.rs

@@ -20,7 +20,7 @@ pub enum ArgError {
     #[error("Error: missing value for {0}")]
     MissingValue(String),
     /// This error is raised if there isn't any configuration given by the user (for example just wordlist feature without any type of characters specified).
-    #[error("Error: no configuration given for argument. Please specify the mandatory parameters and at least one type of characters.\nUsage: worgenX <command> [options]\nTry 'worgenX --help' for more information.")]
+    #[error("Error: no configuration given for argument.\nPlease specify the mandatory parameters and at least one type of characters.\nUsage: worgenX <command> [options]\nTry 'worgenX --help' for more information.")]
     MissingConfiguration,
 }
 
@@ -52,4 +52,7 @@ pub enum SystemError {
     /// This error is raised if there is a thread error.
     #[error("Error: thread error\n{0}")]
     ThreadError(String),
+    /// This error is raised if the hash algorithm is not supported.
+    #[error("Error: the hash algorithm `{0}` is not supported")]
+    UnsupportedHashAlgorithm(String),
 }

src/json.rs

@@ -31,3 +31,36 @@ pub fn password_config_to_json(
     })
     .to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::Value;
+
+    #[test]
+    fn test_password_config_to_json() {
+        let password_config: PasswordConfig = PasswordConfig {
+            numbers: true,
+            special_characters: true,
+            uppercase: true,
+            lowercase: true,
+            length: 10,
+            number_of_passwords: 1,
+        };
+        let passwords: Vec<String> = vec!["password".to_string()];
+        let json_output: String = password_config_to_json(&password_config, &passwords);
+
+        let json_from_str: Value = serde_json::from_str(&json_output).unwrap();
+        let json_expected_object: Value = json!({
+            "number_of_passwords": 1,
+            "password_length": 10,
+            "uppercase": true,
+            "lowercase": true,
+            "numbers": true,
+            "special_characters": true,
+            "passwords": ["password"]
+        });
+
+        assert_eq!(json_from_str, json_expected_object);
+    }
+}

src/main.rs

@@ -1,3 +1,7 @@
+// Prevents the use of unsafe code
+#![forbid(unsafe_code)]
+
+// Prevents the compilation of both modes which may cause conflicts
 #[cfg(all(not(feature = "gui"), not(feature = "cli")))]
 compile_error!("You must specify a mode: 'gui' or 'cli'.");
 

src/mode/cli.rs

@@ -103,12 +103,20 @@ fn build_command_context() -> Command {
                 .help("Disable the loading bar when generating the wordlist")
                 .action(ArgAction::SetTrue),
         )
+        .arg(
+            Arg::new("hash")
+                .short('h')
+                .long("hash")
+                .help("Hash algorithm to use for the wordlist")
+                .value_parser(vec!["md5", "sha1", "sha224", "sha256", "sha384", "sha512", "sha3-224", "sha3-256", "sha3-384", "sha3-512", "blake2b", "blake2s", "whirlpool"])
+                .value_name("hash"),
+        )
         .arg(
             Arg::new("threads_wordlist")
                 .short('t')
                 .long("threads")
                 .help("Number of threads to generate the passwords")
-                .value_parser(value_parser!(u8))
+                .value_parser(value_parser!(u8).range(1..u8::MAX as i64))
                 .value_name("threads")
                 .default_value(default_threads),
         );
@@ -148,7 +156,7 @@ fn build_command_context() -> Command {
                 .short('s')
                 .long("size")
                 .help("Size of the passwords in characters")
-                .value_parser(value_parser!(u32))
+                .value_parser(value_parser!(u32).range(1..u32::MAX as i64))
                 .value_name("size")
                 .required(true),
         )
@@ -157,7 +165,7 @@ fn build_command_context() -> Command {
                 .short('c')
                 .long("count")
                 .help("Number of passwords to generate")
-                .value_parser(value_parser!(u64))
+                .value_parser(value_parser!(u64).range(1..u64::MAX))
                 .value_name("count")
                 .required(true),
         )
@@ -193,7 +201,7 @@ fn build_command_context() -> Command {
                 .short('t')
                 .long("threads")
                 .help("Number of threads to use for the CPU benchmark")
-                .value_parser(value_parser!(u8))
+                .value_parser(value_parser!(u8).range(1..u8::MAX as i64))
                 .value_name("threads")
                 .default_value(default_threads),
         );
@@ -234,21 +242,10 @@ pub fn run() -> Result<(), WorgenXError> {
 
     command_context.build();
     match command_context.get_matches().subcommand() {
-        Some(("wordlist", sub_matches)) => match run_wordlist(sub_matches) {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e),
-        },
-        Some(("password", sub_matches)) => match run_passwd(sub_matches) {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e),
-        },
-        Some(("benchmark", sub_matches)) => match run_benchmark(sub_matches) {
-            Ok(_) => Ok(()),
-            Err(e) => Err(e),
-        },
-        _ => {
-            Err(WorgenXError::ArgError(ArgError::NoArgument)) // Should never happen
-        }
+        Some(("wordlist", sub_matches)) => run_wordlist(sub_matches),
+        Some(("password", sub_matches)) => run_passwd(sub_matches),
+        Some(("benchmark", sub_matches)) => run_benchmark(sub_matches),
+        _ => Err(WorgenXError::ArgError(ArgError::NoArgument)) // Should never happen
     }
 }
 
@@ -377,6 +374,7 @@ 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));
+    println!("Wordlist generation in progress...");
 
     wordlist::wordlist_generation_scheduler(
         &wordlist_config,
@@ -410,13 +408,15 @@ fn allocate_wordlist_config_cli(
         uppercase: false,
         lowercase: false,
         mask: String::new(),
+        hash: String::new(),
     };
 
     update_config(&mut wordlist_values.lowercase, sub_matches, "lowercase_wordlist");
     update_config(&mut wordlist_values.uppercase, sub_matches, "uppercase_wordlist");
     update_config(&mut wordlist_values.numbers, sub_matches, "numbers_wordlist");
     update_config(&mut wordlist_values.special_characters, sub_matches, "special_characters_wordlist");
     update_config(&mut wordlist_values.mask, sub_matches, "mask");
+    update_config(&mut wordlist_values.hash, sub_matches, "hash");
     update_config(&mut output_file, sub_matches, "output");
     update_config(&mut no_loading_bar, sub_matches, "disable_loading_bar");
     update_config(&mut threads, sub_matches, "threads_wordlist");
@@ -543,6 +543,7 @@ fn display_help() {
     println!("    -o <path>, --output <path>\t\tSave the wordlist in a text file");
     println!("\n  The following options are optional:");
     println!("    -d, --disable-loading-bar\t\tDisable the loading bar when generating the wordlist");
+    println!("    -h, --hash <hash>\t\t\tHash algorithm to use for the wordlist.\n\t\t\t\t\tYou can choose between: md5, sha1, sha224, sha256, sha384, sha512,\n\t\t\t\t\tsha3-224, sha3-256, sha3-384, sha3-512, blake2b-512, blake2s-256 and whirlpool");
     println!("    -t <threads>, --threads <threads>\tNumber of threads to generate the passwords\n\t\t\t\t\tBy default, the number of threads is based on the number of physical cores of the CPU");
 
     println!("\n  --- Password generation ---");
@@ -563,3 +564,71 @@ fn display_help() {
     println!("  The following option is optional:");
     println!("    -t <threads>, --threads <threads>\tNumber of threads to use for the CPU benchmark\n\t\t\t\t\tBy default, the number of threads is based on the number of physical cores of the CPU\n");
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_allocate_passwd_config_cli() {
+        let command_context: Command = build_command_context();
+        let matches: ArgMatches = command_context.get_matches_from(vec!["worgenX", "password", "-l", "-u", "-n", "-x", "-s", "10", "-c", "5", "-o", "test.txt", "-j"]);
+        
+        match matches.subcommand(){
+            Some(("password", sub_matches)) => {
+                let result: PasswordGenerationOptions = allocate_passwd_config_cli(sub_matches).unwrap();
+                assert_eq!(result.password_config.number_of_passwords, 5);
+                assert_eq!(result.password_config.length, 10);
+                assert!(result.password_config.lowercase);
+                assert!(result.password_config.uppercase);
+                assert!(result.password_config.numbers);
+                assert!(result.password_config.special_characters);
+                assert!(result.output_file.contains("test.txt"));
+                assert!(result.json);
+                assert!(!result.no_display);
+            },
+            _ => panic!("Should never happen")
+        }
+    }
+
+    #[test]
+    fn test_allocate_wordlist_config_cli() {
+        let command_context: Command = build_command_context();
+        let matches: ArgMatches = command_context.get_matches_from(vec!["worgenX", "wordlist", "-l", "-u", "-n", "-x", "-m", "A?1", "-o", "test.txt", "-d", "-t", "4"]);
+        
+        match matches.subcommand(){
+            Some(("wordlist", sub_matches)) => {
+                let result: WordlistGenerationOptions = allocate_wordlist_config_cli(sub_matches).unwrap();
+                assert_eq!(result.wordlist_values.mask, "A?1");
+                assert_eq!(result.threads, 4);
+                assert!(result.wordlist_values.lowercase);
+                assert!(result.wordlist_values.uppercase);
+                assert!(result.wordlist_values.numbers);
+                assert!(result.wordlist_values.special_characters);
+                assert!(result.output_file.contains("test.txt"));
+                assert!(result.no_loading_bar);
+            },
+            _ => panic!("Should never happen")
+        }
+    }
+
+    #[test]
+    fn test_allocate_benchmark_config_cli() {
+        let command_context: Command = build_command_context();
+        let matches: ArgMatches = command_context.get_matches_from(vec!["worgenX", "benchmark", "-t", "4"]);
+        
+        match matches.subcommand(){
+            Some(("benchmark", sub_matches)) => {
+                let result: BenchmarkOptions = allocate_benchmark_config_cli(sub_matches).unwrap();
+                assert_eq!(result.threads, 4);
+            },
+            _ => panic!("Should never happen")
+        }
+    }
+
+    #[test]
+    fn test_check_output_arg() {
+        let result: Result<String, WorgenXError> = check_output_arg("./test.txt");
+        assert!(result.is_ok());
+    }
+}

src/mode/gui.rs

@@ -26,7 +26,7 @@ use std::{
 pub fn run() {
     loop {
         print_menu();
-        let choice = system::get_user_choice();
+        let choice: String = system::get_user_choice();
         match &*choice {
             "0" => break,
             "1" => main_wordlist_generation(),
@@ -211,6 +211,7 @@ fn main_wordlist_generation() {
             file_result = saving_procedure(target::WORDLISTS_FOLDER);
         }
 
+        println!("Wordlist generation started.");
         let (_, filename) = file_result.unwrap();
         if let Err(e) = wordlist::wordlist_generation_scheduler(
             &wordlist_config,
@@ -243,6 +244,7 @@ fn allocate_wordlist_config_gui() -> WordlistValues {
         uppercase: false,
         lowercase: false,
         mask: String::new(),
+        hash: String::new(),
     };
     let mut is_option_chosen: bool = false;
 
@@ -277,6 +279,11 @@ fn allocate_wordlist_config_gui() -> WordlistValues {
         }
     }
 
+    println!("Do you want to hash the passwords of the wordlist ? (y/n)");
+    if system::get_user_choice_yn().eq("y") {
+        wordlist_config.hash = get_hash_choice();
+    }
+
     println!("\nEnter the mask of the wordlist :");
     println!("For every character you want to be fixed, enter the character itself.");
     println!("For every character you want to be variable, enter a ?.");
@@ -292,10 +299,7 @@ fn allocate_wordlist_config_gui() -> WordlistValues {
             println!("The mask must contain at least one '?' !");
             continue;
         } else {
-            println!(
-                "Do you want to validate the following mask : '{}' ? (y/n)",
-                wordlist_config.mask
-            );
+            println!("Do you want to validate the following mask : '{}' ? (y/n)", wordlist_config.mask);
             if system::get_user_choice_yn().eq("y") {
                 is_valid_mask = true;
             }
@@ -316,10 +320,7 @@ fn main_benchmark() {
         thread::sleep(std::time::Duration::from_secs(5));
         match benchmark::load_cpu_benchmark(num_cpus::get_physical() as u8) {
             Ok(nb_of_passwords) => {
-                println!(
-                    "Your CPU has generated {} passwords in 1 minute",
-                    nb_of_passwords
-                );
+                println!("Your CPU has generated {} passwords in 1 minute", nb_of_passwords);
             }
             Err(e) => {
                 println!("{}", e);
@@ -386,3 +387,40 @@ pub fn saving_procedure(target: &str) -> Result<(File, String), SystemError> {
 
     Ok((file, filename))
 }
+
+/// This function is charged to get the hash choice from the user.
+///
+/// # Returns
+///
+/// The hash choice as a string. It returns an empty string if the user does not want to hash the passwords anymore.
+///
+fn get_hash_choice() -> String {
+    let hash_choices: [&str; 14] = [
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "sha3-224",
+        "sha3-256",
+        "sha3-384",
+        "sha3-512",
+        "blake2b-512",
+        "blake2s-256",
+        "whirlpool",
+        "",
+    ];
+
+    loop {
+        println!("Choose the hash algorithm you want to use :");
+        for (i, hash) in hash_choices.iter().enumerate() {
+            println!("{} : {}", i + 1, if hash.is_empty() { "None" } else { hash });
+        }
+
+        match system::get_user_choice().trim().parse::<usize>() {
+            Ok(n) if n >= 1 && n <= hash_choices.len() => return hash_choices[n - 1].to_string(),
+            _ => println!("Error: please specify a valid option"),
+        }
+    }
+}