Merge branch 'dev' for release 1.2.3

Author: XenorInspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "worgen_x"
-version = "1.2.2"
+version = "1.2.3"
 edition = "2021"
 authors = ["Xen0rInspire"]
 license = "GNU General Public License v3.0"
@@ -15,17 +15,17 @@ cli = ["serde_json", "clap"]
 gui = []
 
 [dependencies]
-rand = { version = "0.8.5", features = ["getrandom"], default-features = false }
-thiserror = "2.0.8"
-num_cpus = "1.16.0"
-serde_json = { version = "1.0.133", optional = true, features = ["std"], default-features = false }
-indicatif = { version = "0.17.9", default-features = false }
-clap = { version = "4.5.23", 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"
+rand = { version = "0.9.0", features = ["thread_rng"], default-features = false }
+thiserror = { version = "2.0.12", default-features = false }
+num_cpus = { version = "1.16.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.32", 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 }
+sha2 = { version = "0.10.8", default-features = false }
+digest = { version = "0.10.7", default-features = false }
+sha3 = { version = "0.10.8", default-features = false }
+blake2 = { version = "0.10.6", default-features = false }
+whirlpool = { version = "0.10.4", default-features = false }

README.md

@@ -111,7 +111,7 @@ You can find below the options for the main features of WorgenX:
     -h, --hash <hash>                   Hash algorithm to use for the wordlist.
                                         You can choose between: md5, sha1, sha224, sha256, sha384, sha512, sha3-224, sha3-256, sha3-384, sha3-512, blake2b, blake2s and whirlpool
     -t <threads>, --threads <threads>   Number of threads to generate the passwords
-                                        By default, the number of threads is based on the number of physical cores of the CPU
+                                        By default, the number of threads is based on the number of logical cores of the CPU
 
   --- Password generation ---
   You must specify at least one of the following options: -l, -u, -n, -x
@@ -133,7 +133,7 @@ You can find below the options for the main features of WorgenX:
   --- CPU Benchmark ---
   The following option is optional:
     -t <threads>, --threads <threads>   Number of threads to use for the CPU benchmark
-                                        By default, the number of threads is based on the number of physical cores of the CPU
+                                        By default, the number of threads is based on the number of logical cores of the CPU
 
 ```
 

src/benchmark.rs

@@ -38,7 +38,7 @@ const PASSWORD_CONFIG: PasswordConfig = PasswordConfig {
 ///
 /// * `Result<u64, WorgenXError>` - The number of passwords generated in 60 seconds, WorgenXError otherwise.
 ///
-pub fn load_cpu_benchmark(nb_of_threads: u8) -> Result<u64, WorgenXError> {
+pub fn load_cpu_benchmark(nb_of_threads: usize) -> Result<u64, WorgenXError> {
     let (tx_progress_bar, rx_progress_bar) = mpsc::channel::<Result<u64, WorgenXError>>();
     let pb: Arc<Mutex<ProgressBar>> = Arc::new(Mutex::new(system::get_progress_bar()));
     let pb_clone: Arc<Mutex<ProgressBar>> = Arc::clone(&pb);

src/error.rs

@@ -16,9 +16,6 @@ pub enum ArgError {
     /// This error is raised if the user doesn't specify any argument.
     #[error("Error: no argument specified\nUsage: worgenX <command> [options]\nTry 'worgenX --help' for more information.")]
     NoArgument,
-    /// This error is raised if the user specifies an argument that requires a value but doesn't give it.
-    #[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.\nPlease specify the mandatory parameters and at least one type of characters.\nUsage: worgenX <command> [options]\nTry 'worgenX --help' for more information.")]
     MissingConfiguration,

src/main.rs

@@ -27,13 +27,10 @@ fn main() {
     mode::gui::run();
 
     #[cfg(feature = "cli")]
-    match mode::cli::run() {
-        Ok(_) => {
-            std::process::exit(0);
-        }
-        Err(e) => {
-            println!("{}", e);
-            std::process::exit(1);
-        }
+    if let Err(e) =  mode::cli::run() {
+        eprintln!("{}", e);
+        std::process::exit(1);
     }
+
+    std::process::exit(0);
 }

src/mode/cli.rs

@@ -31,13 +31,13 @@ struct WordlistGenerationOptions {
     wordlist_values: WordlistValues,
     output_file: String,
     no_loading_bar: bool,
-    threads: u8,
+    threads: usize,
 }
 
 /// This struct is built from the arguments for the benchmark feature.
 ///
 struct BenchmarkOptions {
-    threads: u8,
+    threads: usize,
 }
 
 /// This function is responsible for building the command context of the CLI mode with the clap framework.
@@ -47,7 +47,7 @@ struct BenchmarkOptions {
 /// Command struct containing the different features of WorgenX.
 ///
 fn build_command_context() -> Command {
-    let default_threads: &'static str = Box::leak(num_cpus::get_physical().to_string().into_boxed_str()); // Ensure a static reference to the number of physical cores of the CPU
+    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")
         .arg_required_else_help(true)
         .arg(
@@ -116,7 +116,7 @@ fn build_command_context() -> Command {
                 .short('t')
                 .long("threads")
                 .help("Number of threads to generate the passwords")
-                .value_parser(value_parser!(u8).range(1..u8::MAX as i64))
+                .value_parser(value_parser!(usize))
                 .value_name("threads")
                 .default_value(default_threads),
         );
@@ -201,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).range(1..u8::MAX as i64))
+                .value_parser(value_parser!(usize))
                 .value_name("threads")
                 .default_value(default_threads),
         );
@@ -245,7 +245,7 @@ pub fn run() -> Result<(), WorgenXError> {
         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.
+        _ => Err(WorgenXError::ArgError(ArgError::NoArgument))
     }
 }
 
@@ -313,6 +313,10 @@ fn run_passwd(sub_matches: &ArgMatches) -> Result<(), WorgenXError> {
 fn allocate_passwd_config_cli(
     sub_matches: &ArgMatches,
 ) -> Result<PasswordGenerationOptions, WorgenXError> {
+    // Clap framework ensures that the arguments are present.
+    let length: u32 = *sub_matches.get_one::<u32>("size").unwrap();
+    let size: u64 = *sub_matches.get_one::<u64>("count").unwrap();
+    
     let mut output_file: String = String::new();
     let mut json: bool = false;
     let mut no_display: bool = false;
@@ -322,8 +326,8 @@ fn allocate_passwd_config_cli(
             special_characters: false,
             uppercase: false,
             lowercase: false,
-            length: *sub_matches.get_one::<u32>("size").ok_or(WorgenXError::ArgError(ArgError::MissingValue("-s or --size".to_string())))?,
-            number_of_passwords: *sub_matches.get_one::<u64>("count").ok_or(WorgenXError::ArgError(ArgError::MissingValue("-c or --count".to_string())))?,
+            length,
+            number_of_passwords: size,
         };
 
     update_config(&mut password_config.lowercase, sub_matches, "lowercase_password");
@@ -401,7 +405,7 @@ fn allocate_wordlist_config_cli(
 ) -> Result<WordlistGenerationOptions, WorgenXError> {
     let mut output_file: String = String::new();
     let mut no_loading_bar: bool = false;
-    let mut threads: u8 = 0;
+    let mut threads: usize = 0;
     let mut wordlist_values: WordlistValues = WordlistValues {
         numbers: false,
         special_characters: false,
@@ -472,7 +476,7 @@ fn run_benchmark(sub_matches: &ArgMatches) -> Result<(), WorgenXError> {
 fn allocate_benchmark_config_cli(
     sub_matches: &ArgMatches,
 ) -> Result<BenchmarkOptions, WorgenXError> {
-    let mut threads: u8 = 0;
+    let mut threads: usize = 0;
     update_config(&mut threads, sub_matches, "threads_benchmark");
 
     Ok(BenchmarkOptions { threads })
@@ -541,7 +545,7 @@ fn display_help() {
     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!("    -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 logical cores of the CPU");
 
     println!("\n  --- Password generation ---");
     println!("  You must specify at least one of the following options: -l, -u, -n, -x");
@@ -559,7 +563,7 @@ fn display_help() {
 
     println!("\n  --- CPU Benchmark ---");
     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");
+    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 logical cores of the CPU\n");
 }
 
 #[cfg(test)]
@@ -592,7 +596,7 @@ mod tests {
         let result: WordlistGenerationOptions = allocate_wordlist_config_cli(sub_matches).unwrap();
 
         assert_eq!(result.wordlist_values.mask, "A?1");
-        assert_eq!(result.threads, 4);
+        assert_eq!(result.threads, 4_usize);
         assert!(result.wordlist_values.lowercase);
         assert!(result.wordlist_values.uppercase);
         assert!(result.wordlist_values.numbers);
@@ -608,7 +612,7 @@ mod tests {
         let (_, sub_matches) = matches.subcommand().unwrap();
         let result: BenchmarkOptions = allocate_benchmark_config_cli(sub_matches).unwrap();
 
-        assert_eq!(result.threads, 4);
+        assert_eq!(result.threads, 4_usize);
     }
 
     #[test]

src/mode/gui.rs

@@ -216,7 +216,7 @@ fn main_wordlist_generation() {
         if let Err(e) = wordlist::wordlist_generation_scheduler(
             &wordlist_config,
             nb_of_passwords,
-            num_cpus::get_physical() as u8,
+            num_cpus::get(),
             &filename,
             false,
         ) {
@@ -318,7 +318,7 @@ fn main_benchmark() {
     while again.eq("y") {
         println!("The benchmark will start in 5 seconds...");
         thread::sleep(std::time::Duration::from_secs(5));
-        match benchmark::load_cpu_benchmark(num_cpus::get_physical() as u8) {
+        match benchmark::load_cpu_benchmark(num_cpus::get()) {
             Ok(nb_of_passwords) => {
                 println!("Your CPU has generated {} passwords in 1 minute", nb_of_passwords);
             }

src/password.rs

@@ -2,7 +2,7 @@
 use crate::dict;
 
 // External crates.
-use rand::{rngs::OsRng, seq::SliceRandom, Rng};
+use rand::{rngs::ThreadRng, seq::SliceRandom, Rng};
 
 /// This struct built from the user's choices will be used to generate the random password.
 ///
@@ -47,7 +47,7 @@ fn create_passwd_content(password_config: &PasswordConfig) -> Vec<u8> {
         password_content.extend(shuffle_dict(dict::SPECIAL_CHARACTERS));
     }
 
-    let mut rng: OsRng = OsRng;
+    let mut rng: ThreadRng = rand::rng();
     password_content.shuffle(&mut rng);
     password_content
 }
@@ -64,7 +64,7 @@ fn create_passwd_content(password_config: &PasswordConfig) -> Vec<u8> {
 ///
 fn shuffle_dict(dict: &[u8]) -> Vec<u8> {
     let mut shuffled_dict: Vec<u8> = dict.to_vec();
-    let mut rng: OsRng = OsRng;
+    let mut rng: ThreadRng = rand::rng();
     shuffled_dict.shuffle(&mut rng);
     shuffled_dict
 }
@@ -85,10 +85,10 @@ pub fn generate_random_passwords(password_config: &PasswordConfig) -> Vec<String
     let password_content: Vec<u8> = create_passwd_content(password_config);
 
     for _ in 0..password_config.number_of_passwords {
-        let mut rng: OsRng = OsRng;
+        let mut rng: ThreadRng = rand::rng();
         let mut password: String = String::new();
         for _ in 0..password_config.length {
-            let idx: usize = rng.gen_range(0..password_content.len());
+            let idx: usize = rng.random_range(0..password_content.len());
             password.push(password_content[idx] as char);
         }
         passwords.push(password);
@@ -112,7 +112,7 @@ mod tests {
             number_of_passwords: 1,
         };
         let password_content: Vec<u8> = create_passwd_content(&password_config);
-        
+
         assert_eq!(password_content.len(), 91);
     }
 

src/system.rs

@@ -149,7 +149,7 @@ pub fn is_valid_path(path: &str) -> Result<String, SystemError> {
                 ))
             }
         };
-        current_dir + "/" + path
+        current_dir + "/" + path.trim_start_matches("./")
     } else {
         path.to_string()
     };
@@ -312,7 +312,7 @@ pub fn get_progress_bar() -> indicatif::ProgressBar {
     pb
 }
 
-/// This functions is responsible for returning the estimated size of the wordlist.
+/// This function is responsible for returning the estimated size of the wordlist.
 ///
 /// # Arguments
 ///
@@ -352,7 +352,7 @@ pub fn get_estimated_size(nb_of_passwords: u64, length: u64) -> String {
     size_str
 }
 
-/// This functions is responsible for managing password hashing.
+/// This function is responsible for managing password hashing.
 /// It returns the hashed password from the hash algorithm specified by the user.
 /// If the hash algorithm is not supported, it returns an error.
 ///
@@ -384,7 +384,7 @@ pub fn manage_hash(password: String, hash: &str) -> Result<String, SystemError>
     }
 }
 
-/// This functions is responsible for hashing a password with a specific hash algorithm.
+/// This function is responsible for hashing a password with a specific hash algorithm.
 /// It returns the hashed password.
 ///
 /// # Arguments

src/wordlist.rs

@@ -164,7 +164,7 @@ pub fn build_wordlist_config(wordlist_values: &WordlistValues) -> WordlistConfig
 pub fn wordlist_generation_scheduler(
     wordlist_config: &WordlistConfig,
     nb_of_passwords: u64,
-    nb_of_threads: u8,
+    nb_of_threads: usize,
     file_path: &str,
     no_loading_bar: bool,
 ) -> Result<(), WorgenXError> {
@@ -217,7 +217,7 @@ pub fn wordlist_generation_scheduler(
 fn run_wordlist_generation(
     wordlist_config: &WordlistConfig,
     nb_of_passwords: u64,
-    nb_of_threads: u8,
+    nb_of_threads: usize,
     file_path: &str,
 ) -> Result<(), WorgenXError> {
     let shared_formated_mask: Arc<Vec<char>> = Arc::new(wordlist_config.formated_mask.clone());