Merge pull request #1 from s-b-repo/rewrite

Rewrite

Author: s-b-repo

Cargo.toml

@@ -18,7 +18,7 @@ anyhow = "1.0.97"
 
 #teminal color
 colored = "3.0.0"
-
+rustyline = "15.0.0"
 #ftp brute force module
 async_ftp = "6.0.0"
 
@@ -28,3 +28,5 @@ tokio-socks = "0.5.2"
 threadpool = "1.8.1"
 crossbeam-channel = "0.5.15"
 telnet = "0.2.3"
+
+walkdir = "2.5.0"

src/commands/creds.rs

@@ -1,26 +1,19 @@
-use anyhow::Result;
-use crate::modules::creds;
-use crate::modules::creds::telnet_bruteforce;
+use anyhow::{Result, bail};
+
+use crate::modules::creds::generic::{
+    ftp_anonymous,
+    ftp_bruteforce,
+    sample_cred_check,
+    telnet_bruteforce,
+};
 
 pub async fn run_cred_check(module_name: &str, target: &str) -> Result<()> {
     match module_name {
-        "sample_cred_check" => {
-            creds::sample_cred_check::run(target).await?;
-        },
-        "ftp_bruteforce" => {
-        creds::ftp_bruteforce::run(target).await?;
-        },
-        "ftp_anonymous" => {
-            creds::ftp_anonymous::run(target).await?;
-        },
-
-        "telnet_bruteforce" =>  {
-        telnet_bruteforce::run_module(target).await?;
-         },
-        // Add more creds modules here ...
-        _ => {
-            eprintln!("Creds module '{}' not found.", module_name);
-        },
+        "generic/sample_cred_check"     => sample_cred_check::run(target).await?,
+        "generic/ftp_bruteforce"    => ftp_bruteforce::run(target).await?,
+        "generic/ftp_anonymous"     => ftp_anonymous::run(target).await?,
+        "generic/telnet_bruteforce" => telnet_bruteforce::run(target).await?,
+        _ => bail!("Creds module '{}' not found.", module_name),
     }
 
     Ok(())

src/commands/mod.rs

@@ -1,51 +1,96 @@
-// src/commands/mod.rs
-
 pub mod exploit;
 pub mod scanner;
 pub mod creds;
 
 use anyhow::Result;
 use crate::cli::Cli;
+use walkdir::WalkDir;
 
-
+/// Handle CLI commands like: --command exploit --module creds/generic/ftp_anonymous --target x.x.x.x
 pub async fn handle_command(command: &str, cli_args: &Cli) -> Result<()> {
+    let target = cli_args.target.clone().unwrap_or_default();
+    let module = cli_args.module.clone().unwrap_or_default();
+
     match command {
         "exploit" => {
-            let target = cli_args.target.clone().unwrap_or_default();
-            let module = cli_args.module.clone().unwrap_or_default();
-            exploit::run_exploit(&module, &target).await?;
+            let trimmed = module.trim_start_matches("exploits/"); // normalize
+            exploit::run_exploit(trimmed, &target).await?;
         },
         "scanner" => {
-            let target = cli_args.target.clone().unwrap_or_default();
-            let module = cli_args.module.clone().unwrap_or_default();
-            scanner::run_scan(&module, &target).await?;
+            let trimmed = module.trim_start_matches("scanners/");
+            scanner::run_scan(trimmed, &target).await?;
         },
         "creds" => {
-            let target = cli_args.target.clone().unwrap_or_default();
-            let module = cli_args.module.clone().unwrap_or_default();
-            creds::run_cred_check(&module, &target).await?;
+            let trimmed = module.trim_start_matches("creds/");
+            creds::run_cred_check(trimmed, &target).await?;
         },
         _ => {
             eprintln!("Unknown command '{}'", command);
         }
     }
+
     Ok(())
 }
 
-// Called from the interactive shell
+/// Called from the interactive shell (e.g. 'use creds/generic/ftp_anonymous' + 'run')
 pub async fn run_module(module_path: &str, target: &str) -> Result<()> {
-    if module_path.starts_with("exploits/") {
-        let module_name = module_path.trim_start_matches("exploits/").to_string();
-        exploit::run_exploit(&module_name, target).await?;
-    } else if module_path.starts_with("scanners/") {
-        let module_name = module_path.trim_start_matches("scanners/").to_string();
-        scanner::run_scan(&module_name, target).await?;
-    } else if module_path.starts_with("creds/") {
-        let module_name = module_path.trim_start_matches("creds/").to_string();
-        creds::run_cred_check(&module_name, target).await?;
-    } else {
-        eprintln!("Unknown module path '{}'", module_path);
+    let available = discover_modules();
+
+    if !available.contains(&module_path.to_string()) {
+        eprintln!("Unknown module '{}'. Available modules:", module_path);
+        for module in available {
+            println!("  {}", module);
+        }
+        return Ok(());
+    }
+
+    // Split path like "creds/generic/ftp_anonymous" -> ("creds", "generic/ftp_anonymous")
+    let mut parts = module_path.splitn(2, '/');
+    let category = parts.next().unwrap_or("");
+    let module_name = parts.next().unwrap_or("");
+
+    match category {
+        "exploits" => {
+            exploit::run_exploit(module_name, target).await?;
+        },
+        "scanners" => {
+            scanner::run_scan(module_name, target).await?;
+        },
+        "creds" => {
+            creds::run_cred_check(module_name, target).await?;
+        },
+        _ => {
+            eprintln!("Category '{}' is not supported.", category);
+        }
     }
 
     Ok(())
 }
+
+/// Discover modules in src/modules/{exploits,scanners,creds} recursively up to 6 levels deep
+pub fn discover_modules() -> Vec<String> {
+    let mut modules = Vec::new();
+
+    let categories = ["exploits", "scanners", "creds"];
+
+    for category in categories {
+        let base_path = format!("src/modules/{}", category);
+        let walker = WalkDir::new(&base_path).max_depth(6);
+
+        for entry in walker.into_iter().filter_map(|e| e.ok()) {
+            let path = entry.path();
+
+            if path.is_file() && path.extension().map(|e| e == "rs").unwrap_or(false) {
+                if let Ok(relative) = path.strip_prefix("src/modules") {
+                    let module_path = relative
+                        .with_extension("") // remove .rs
+                        .to_string_lossy()
+                        .replace("\\", "/"); // Windows compatibility
+                    modules.push(module_path);
+                }
+            }
+        }
+    }
+
+    modules
+}

src/modules/creds/ftp_anonymous.rs renamed to src/modules/creds/generic/ftp_anonymous.rs

@@ -0,0 +1,6 @@
+
+    pub mod sample_cred_check;
+    pub mod ftp_bruteforce;
+    pub mod ftp_anonymous;
+    pub mod telnet_bruteforce;
+

src/modules/creds/ftp_bruteforce.rs renamed to src/modules/creds/generic/ftp_bruteforce.rs

@@ -8,7 +8,7 @@ use threadpool::ThreadPool;
 use crossbeam_channel::{unbounded};
 use telnet::Telnet;
 
-pub async fn run_module(target: &str) -> Result<()> {
+pub async fn run(target: &str) -> Result<()> {
     println!("\n=== Telnet Bruteforce Module (RustSploit) ===\n");
 
     let target = target.to_string();

src/modules/creds/generic/mod.rs

@@ -1,4 +1 @@
-pub mod sample_cred_check;
-pub mod ftp_bruteforce;
-pub mod ftp_anonymous;
-pub mod telnet_bruteforce;
+pub mod generic; // <-- lowercase folder name

src/modules/creds/sample_cred_check.rs renamed to src/modules/creds/generic/sample_cred_check.rs

@@ -1,49 +1,73 @@
 use colored::*;
 use std::fs;
-use std::path::Path;
+use std::path::{Path,};
 
-/// Dynamically checks if a module path exists
-pub fn module_exists(module_path: &str) -> bool {
-    if let Some((category, name)) = module_path.split_once('/') {
-        let path = format!("src/modules/{}/{}.rs", category, name);
-        Path::new(&path).exists()
-    } else {
-        false
+/// Maximum folder depth to traverse
+const MAX_DEPTH: usize = 6;
+
+/// Recursively list .rs files up to a certain depth
+fn collect_module_paths(dir: &Path, depth: usize) -> Vec<String> {
+    let mut modules = Vec::new();
+
+    if depth > MAX_DEPTH || !dir.exists() {
+        return modules;
     }
-}
 
-/// Lists all available modules in exploits, scanners, and creds
-pub fn list_all_modules() {
-    let categories = [
-        ("exploits", "Exploits"),
-        ("scanners", "Scanners"),
-        ("creds", "Credentials"),
-    ];
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
 
-    println!("{}", "Available modules:".bold().underline());
+            if path.is_dir() {
+                modules.extend(collect_module_paths(&path, depth + 1));
+            } else if let Some(file_name) = path.file_name().and_then(|s| s.to_str()) {
+                if file_name.ends_with(".rs") && file_name != "mod.rs" {
+                    let relative_path = path
+                        .strip_prefix("src/modules")
+                        .unwrap_or(&path)
+                        .with_extension("")
+                        .to_string_lossy()
+                        .replace('\\', "/"); // For Windows compatibility
 
-    for (folder, display_name) in categories {
-        let mut modules = Vec::new();
-        let dir_path = format!("src/modules/{}", folder);
-
-        if let Ok(entries) = fs::read_dir(&dir_path) {
-            for entry in entries.flatten() {
-                if let Some(file_name) = entry.file_name().to_str() {
-                    if file_name.ends_with(".rs") && file_name != "mod.rs" {
-                        let module_name = file_name.trim_end_matches(".rs").to_string();
-                        modules.push(module_name);
-                    }
+                    modules.push(relative_path);
                 }
             }
         }
+    }
 
-        modules.sort();
+    modules
+}
 
-        if !modules.is_empty() {
-            println!("\n{}:", display_name.blue().bold());
-            for module in modules {
-                println!("  - {}", format!("{}/{}", folder, module).green());
-            }
+/// Dynamically checks if a module path exists at any depth
+pub fn module_exists(module_path: &str) -> bool {
+    let modules = collect_module_paths(Path::new("src/modules"), 0);
+    modules.iter().any(|m| m == module_path)
+}
+
+/// Lists all available modules recursively under src/modules/
+pub fn list_all_modules() {
+    println!("{}", "Available modules:".bold().underline());
+
+    let modules = collect_module_paths(Path::new("src/modules"), 0);
+    if modules.is_empty() {
+        println!("{}", "No modules found.".red());
+        return;
+    }
+
+    let mut grouped = std::collections::BTreeMap::new();
+
+    for module in modules {
+        let parts: Vec<&str> = module.split('/').collect();
+        let category = parts.get(0).unwrap_or(&"Other").to_string();
+        grouped
+            .entry(category)
+            .or_insert_with(Vec::new)
+            .push(module.clone());
+    }
+
+    for (category, paths) in grouped {
+        println!("\n{}:", category.blue().bold());
+        for path in paths {
+            println!("  - {}", path.green());
         }
     }
 }