feat: Add comprehensive threading support to all scanning modules

- Add threading support to 9 modules: subdomains, dalfox, nuclei, ports, sqlmap, livehosts, tech, urls, backup_scan
- Set default thread count to 100 for all tools
- Update Discord bot commands with threading parameters
- Add performance guidelines and configuration documentation
- Improve parallel processing capabilities across all scanning tools

Modules updated:
- subdomains.sh: Subfinder threading (-t parameter)
- dalfox.sh: Dalfox threading (-w parameter)
- nuclei.sh: Nuclei threading (-c parameter)
- ports.sh: Naabu threading (-tp and -rate parameters)
- sqlmap.sh: Interlace threading (-threads parameter)
- livehosts.sh: Httpx threading (-threads parameter)
- tech.sh: Httpx threading (-threads parameter)
- urls.sh: Urlfinder and JSFinder threading (-t and -c parameters)
- backup_scan.sh: Fuzzuli threading (-w parameter)

Discord commands updated:
- All commands now support optional threads parameter (default: 100)
- Updated command descriptions and help text
- Added performance tuning capabilities

Documentation:
- Added comprehensive threading configuration section
- Updated README with performance guidelines
- Added CLI and Discord command examples
- Documented all supported tools with threading

Author: h0tak88r

README.md

@@ -34,13 +34,31 @@ AutoAR is a comprehensive, modular security automation toolkit designed for bug
 - **File Sharing**: Automatic result file uploads
 - **Slash Commands**: Easy-to-use Discord commands
 - **Progress Tracking**: Real-time scan status updates
+- **Configurable Threading**: All tools support custom thread counts for optimal performance
 
 ### 🗄️ **Database Support**
 - **PostgreSQL Integration**: Full database support for results storage
 - **SQLite Fallback**: Lightweight database option
 - **Data Export**: Easy data export and analysis
 - **Result Management**: Organized result storage and retrieval
 
+### ⚡ **Performance & Threading**
+- **Configurable Threading**: All scanning tools support custom thread counts (default: 100)
+- **Parallel Processing**: Optimized for multi-core systems with concurrent operations
+- **Resource Management**: Intelligent thread allocation based on tool capabilities
+- **Performance Tuning**: Easy adjustment of thread counts via Discord commands or CLI flags
+
+**Supported Tools with Threading:**
+- **Subdomain Enumeration**: Subfinder with configurable thread pools
+- **Live Host Detection**: Httpx with parallel HTTP probing
+- **Vulnerability Scanning**: Nuclei with concurrent template execution
+- **Port Scanning**: Naabu with high-speed parallel port discovery
+- **XSS Detection**: Dalfox with concurrent payload testing
+- **SQL Injection Testing**: SQLMap with Interlace for parallel testing
+- **Technology Detection**: Httpx with parallel technology fingerprinting
+- **URL Collection**: Urlfinder and JSFinder with concurrent crawling
+- **Backup File Discovery**: Fuzzuli with parallel backup file enumeration
+
 ## 🚀 Quick Start
 
 ### Docker Compose (Recommended)
@@ -119,18 +137,18 @@ python discord_bot.py
 Once the bot is running, use these slash commands in Discord:
 
 #### Basic Reconnaissance
-- `/subdomains domain:example.com` - Enumerate subdomains
-- `/livehosts domain:example.com` - Find live hosts
+- `/subdomains domain:example.com [threads:100]` - Enumerate subdomains
+- `/livehosts domain:example.com [threads:100]` - Find live hosts
 - `/cnames domain:example.com` - Extract CNAME records
-- `/urls domain:example.com` - Collect URLs
-- `/tech domain:example.com` - Detect technologies
+- `/urls domain:example.com [threads:100]` - Collect URLs
+- `/tech domain:example.com [threads:100]` - Detect technologies
 
 #### Vulnerability Scanning
-- `/nuclei domain:example.com` - Run Nuclei scans
+- `/nuclei domain:example.com [threads:100]` - Run Nuclei scans
 - `/wpdepconf domain:example.com` - WordPress plugin confusion
-- `/dalfox domain:example.com` - XSS detection
-- `/sqlmap domain:example.com` - SQL injection testing
-- `/backup domain:example.com` - Backup file discovery
+- `/dalfox domain:example.com [threads:100]` - XSS detection
+- `/sqlmap domain:example.com [threads:100]` - SQL injection testing
+- `/backup_scan domain:example.com [threads:100] [full:false]` - Backup file discovery
 
 #### Specialized Scans
 - `/js domain:example.com` - JavaScript analysis
@@ -139,7 +157,7 @@ Once the bot is running, use these slash commands in Discord:
 - `/github-wordlist org:company` - Generate wordlists from GitHub org
 - `/s3 bucket:example-bucket` - S3 bucket scanning
 - `/dns domain:example.com` - DNS takeover detection
-- `/ports domain:example.com` - Port scanning
+- `/ports domain:example.com [threads:100]` - Port scanning
 
 #### GitHub Reconnaissance
 - `/github scan repo:microsoft/PowerShell` - Scan specific repository for secrets
@@ -159,17 +177,20 @@ Access the container and use the CLI directly:
 # Enter the container
 docker exec -it autoar-bot bash
 
-# Basic reconnaissance
-/app/main.sh subdomains get -d example.com
-/app/main.sh livehosts get -d example.com
+# Basic reconnaissance (with threading)
+/app/main.sh subdomains get -d example.com -t 100
+/app/main.sh livehosts get -d example.com -t 100
 /app/main.sh cnames get -d example.com
-/app/main.sh urls collect -d example.com
-
-# Vulnerability scanning
-/app/main.sh nuclei run -d example.com
+/app/main.sh urls collect -d example.com -t 100
+/app/main.sh tech detect -d example.com -t 100
+
+# Vulnerability scanning (with threading)
+/app/main.sh nuclei run -d example.com -t 100
+/app/main.sh dalfox run -d example.com -t 100
+/app/main.sh sqlmap run -d example.com -t 100
+/app/main.sh ports scan -d example.com -t 100
+/app/main.sh backup scan -d example.com -t 100 --full
 /app/main.sh wpDepConf scan -d example.com
-/app/main.sh dalfox run -d example.com
-/app/main.sh sqlmap run -d example.com
 
 # Specialized scans
 /app/main.sh js scan -d example.com
@@ -274,6 +295,37 @@ GITHUB_TOKEN=your_github_personal_access_token
 - `read:org` - Read organization membership
 - `read:user` - Read user profile information
 
+## ⚡ Threading Configuration
+
+AutoAR supports configurable threading across all scanning tools for optimal performance:
+
+### Discord Commands
+All Discord commands support optional `threads` parameter (default: 100):
+```
+/subdomains domain:example.com threads:200
+/nuclei domain:example.com threads:50
+/ports domain:example.com threads:500
+```
+
+### CLI Commands
+All CLI commands support `-t` or `--threads` flag:
+```bash
+# High-performance scanning
+./modules/subdomains.sh get -d example.com -t 200
+./modules/nuclei.sh run -d example.com -t 50
+./modules/ports.sh scan -d example.com -t 500
+
+# Conservative scanning (lower resource usage)
+./modules/subdomains.sh get -d example.com -t 25
+./modules/nuclei.sh run -d example.com -t 10
+```
+
+### Performance Guidelines
+- **High-end systems**: 200-500 threads for maximum speed
+- **Standard systems**: 100 threads (default) for balanced performance
+- **Resource-constrained**: 25-50 threads to avoid overwhelming the system
+- **Network-limited**: Lower thread counts to avoid rate limiting
+
 ## 🔧 Configuration
 
 ### Environment Variables

discord_bot.py

@@ -447,12 +447,12 @@ async def github_wordlist(self, interaction: discord.Interaction, org: str,
     @app_commands.command(name="backup_scan", description="Discover backup files using Fuzzuli")
     @app_commands.describe(
         domain="Target domain to scan for backup files",
-        threads="Number of threads (default: 10)",
+        threads="Number of threads (default: 100)",
         delay="Delay between requests in ms (default: 100)",
         full="Run full backup scan on all subdomains (default: False)"
     )
     async def backup_scan(self, interaction: discord.Interaction, domain: str, 
-                         threads: int = 10, delay: int = 100, full: bool = False):
+                         threads: int = 100, delay: int = 100, full: bool = False):
         """Discover backup files using Fuzzuli."""
         scan_id = f"backup_{int(time.time())}"
 
@@ -592,10 +592,13 @@ async def scan_status(self, interaction: discord.Interaction):
         await interaction.response.send_message(embed=embed)
 
     @app_commands.command(name="subdomains", description="Enumerate subdomains")
-    @app_commands.describe(domain="The domain to enumerate")
-    async def subdomains_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain to enumerate",
+        threads="Number of threads for subfinder (default: 100)"
+    )
+    async def subdomains_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"subdomains_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "subdomains", "get", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "subdomains", "get", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'subdomains', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Subdomains", domain, "running")
         await interaction.response.send_message(embed=embed)
@@ -612,20 +615,26 @@ async def cnames_cmd(self, interaction: discord.Interaction, domain: str):
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="livehosts", description="Filter live hosts from subdomains")
-    @app_commands.describe(domain="The domain")
-    async def livehosts_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for httpx (default: 100)"
+    )
+    async def livehosts_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"live_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "livehosts", "get", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "livehosts", "get", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'live', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Live Hosts", domain, "running")
         await interaction.response.send_message(embed=embed)
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="urls", description="Collect URLs and JS URLs")
-    @app_commands.describe(domain="The domain")
-    async def urls_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for urlfinder and jsfinder (default: 100)"
+    )
+    async def urls_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"urls_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "urls", "collect", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "urls", "collect", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'urls', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("URLs", domain, "running")
         await interaction.response.send_message(embed=embed)
@@ -644,30 +653,39 @@ async def reflection_cmd(self, interaction: discord.Interaction, domain: str):
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="nuclei", description="Run nuclei templates on live subdomains")
-    @app_commands.describe(domain="The domain")
-    async def nuclei_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for nuclei (default: 100)"
+    )
+    async def nuclei_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"nuclei_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "nuclei", "run", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "nuclei", "run", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'nuclei', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Nuclei", domain, "running")
         await interaction.response.send_message(embed=embed)
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="tech", description="Detect technologies on live hosts")
-    @app_commands.describe(domain="The domain")
-    async def tech_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for httpx (default: 100)"
+    )
+    async def tech_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"tech_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "tech", "detect", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "tech", "detect", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'tech', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Tech Detect", domain, "running")
         await interaction.response.send_message(embed=embed)
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="ports", description="Run port scan (naabu) on live hosts")
-    @app_commands.describe(domain="The domain")
-    async def ports_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for naabu (default: 100)"
+    )
+    async def ports_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"ports_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "ports", "scan", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "ports", "scan", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'ports', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Ports", domain, "running")
         await interaction.response.send_message(embed=embed)
@@ -684,20 +702,26 @@ async def gf_cmd(self, interaction: discord.Interaction, domain: str):
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="sqlmap", description="Run SQLMap on GF SQLi results")
-    @app_commands.describe(domain="The domain")
-    async def sqlmap_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for sqlmap (default: 100)"
+    )
+    async def sqlmap_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"sqlmap_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "sqlmap", "run", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "sqlmap", "run", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'sqlmap', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("SQLMap", domain, "running")
         await interaction.response.send_message(embed=embed)
         asyncio.create_task(self._run_scan_background(scan_id, command))
 
     @app_commands.command(name="dalfox", description="Run Dalfox XSS scan")
-    @app_commands.describe(domain="The domain")
-    async def dalfox_cmd(self, interaction: discord.Interaction, domain: str):
+    @app_commands.describe(
+        domain="The domain",
+        threads="Number of threads for dalfox (default: 100)"
+    )
+    async def dalfox_cmd(self, interaction: discord.Interaction, domain: str, threads: int = 100):
         scan_id = f"dalfox_{int(time.time())}"
-        command = [AUTOAR_SCRIPT_PATH, "dalfox", "run", "-d", domain]
+        command = [AUTOAR_SCRIPT_PATH, "dalfox", "run", "-d", domain, "-t", str(threads)]
         active_scans[scan_id] = { 'type': 'dalfox', 'target': domain, 'status': 'running', 'start_time': datetime.now(), 'interaction': interaction }
         embed = self.create_scan_embed("Dalfox", domain, "running")
         await interaction.response.send_message(embed=embed)

modules/backup_scan.sh

@@ -16,13 +16,13 @@ usage() {
   echo "  -d, --domain     Target domain to scan"
   echo "  -l, --live-hosts File containing list of live hosts"
   echo "  -o, --output     Output directory (default: results/<domain>/backup or results/backup)"
-  echo "  -t, --threads    Number of threads/workers (default: 10)"
+  echo "  -t, --threads    Number of threads/workers (default: 100)"
   echo "  -d, --delay      Delay between requests in ms (default: 100)"
   echo "  --full           Run full backup scan on all subdomains (collects subdomains first)"
 }
 
 backup_scan() {
-  local domain="" live_hosts_file="" output_dir="" threads="10" delay="100" full_mode=false
+  local domain="" live_hosts_file="" output_dir="" threads="100" delay="100" full_mode=false
 
   while [[ $# -gt 0 ]]; do
     case "$1" in

modules/dalfox.sh

@@ -6,12 +6,17 @@ source "$ROOT_DIR/lib/logging.sh"
 source "$ROOT_DIR/lib/utils.sh"
 source "$ROOT_DIR/lib/discord.sh"
 
-usage() { echo "Usage: dalfox run -d <domain>"; }
+usage() { 
+  echo "Usage: dalfox run -d <domain> [-t <threads>]"
+  echo "  -d, --domain     Target domain to scan"
+  echo "  -t, --threads    Number of threads for dalfox (default: 100)"
+}
 
 dalfox_run() {
-  local domain=""; while [[ $# -gt 0 ]]; do
+  local domain="" threads="100"; while [[ $# -gt 0 ]]; do
     case "$1" in
       -d|--domain) domain="$2"; shift 2;;
+      -t|--threads) threads="$2"; shift 2;;
       *) usage; exit 1;;
     esac
   done
@@ -32,7 +37,8 @@ dalfox_run() {
   [[ -s "$in_file" ]] || { log_warn "No XSS candidate file at $in_file after GF scan"; exit 0; }
 
   if command -v dalfox >/dev/null 2>&1; then
-    dalfox file "$in_file" --no-spinner --only-poc r --ignore-return 302,404,403 --skip-bav -b "0x88.xss.cl" -w 50 -o "$out_file" 2>/dev/null || true
+    log_info "Running dalfox with $threads threads"
+    dalfox file "$in_file" --no-spinner --only-poc r --ignore-return 302,404,403 --skip-bav -b "0x88.xss.cl" -w "$threads" -o "$out_file" 2>/dev/null || true
   fi
   [[ -s "$out_file" ]] && discord_send_file "$out_file" "Dalfox results for $domain"
 }

modules/livehosts.sh

@@ -8,12 +8,17 @@ source "$ROOT_DIR/lib/config.sh"
 source "$ROOT_DIR/lib/discord.sh"
 source "$ROOT_DIR/lib/db.sh"
 
-usage() { echo "Usage: livehosts get -d <domain>"; }
+usage() { 
+  echo "Usage: livehosts get -d <domain> [-t <threads>]"
+  echo "  -d, --domain     Target domain to scan"
+  echo "  -t, --threads    Number of threads for httpx (default: 100)"
+}
 
 livehosts_get() {
-  local domain=""; while [[ $# -gt 0 ]]; do
+  local domain="" threads="100"; while [[ $# -gt 0 ]]; do
     case "$1" in
       -d|--domain) domain="$2"; shift 2;;
+      -t|--threads) threads="$2"; shift 2;;
       *) usage; exit 1;;
     esac
   done
@@ -26,9 +31,9 @@ livehosts_get() {
   # Ensure subdomains exist (from DB or enumeration)
   ensure_subdomains "$domain" "$subs_dir/all-subs.txt" || { log_warn "Failed to get subdomains for $domain"; exit 1; }
 
-  log_info "Filtering live hosts via httpx"
+  log_info "Filtering live hosts via httpx with $threads threads"
   if command -v httpx >/dev/null 2>&1; then
-    cat "$subs_dir/all-subs.txt" | httpx -silent -nc -o "$subs_dir/live-subs.txt" >/dev/null 2>&1 || true
+    cat "$subs_dir/all-subs.txt" | httpx -silent -nc -threads "$threads" -o "$subs_dir/live-subs.txt" >/dev/null 2>&1 || true
   else
     : > "$subs_dir/live-subs.txt"
   fi

modules/nuclei.sh

@@ -7,12 +7,17 @@ source "$ROOT_DIR/lib/utils.sh"
 source "$ROOT_DIR/lib/config.sh"
 source "$ROOT_DIR/lib/discord.sh"
 
-usage() { echo "Usage: nuclei run -d <domain>"; }
+usage() { 
+  echo "Usage: nuclei run -d <domain> [-t <threads>]"
+  echo "  -d, --domain     Target domain to scan"
+  echo "  -t, --threads    Number of threads for nuclei (default: 100)"
+}
 
 nuclei_run() {
-  local domain=""; while [[ $# -gt 0 ]]; do
+  local domain="" threads="100"; while [[ $# -gt 0 ]]; do
     case "$1" in
       -d|--domain) domain="$2"; shift 2;;
+      -t|--threads) threads="$2"; shift 2;;
       *) usage; exit 1;;
     esac
   done
@@ -29,8 +34,9 @@ nuclei_run() {
   ensure_live_hosts "$domain" "$subs_dir/live-subs.txt" || { log_warn "Failed to get live hosts for $domain"; exit 1; }
 
   if command -v nuclei >/dev/null 2>&1; then
-    [[ -s "$subs_dir/live-subs.txt" ]] && nuclei -l "$subs_dir/live-subs.txt" -t nuclei_templates/Others -o "$out1" >/dev/null 2>&1 || true
-    [[ -s "$subs_dir/live-subs.txt" ]] && nuclei -l "$subs_dir/live-subs.txt" -t nuclei-templates/http -o "$out2" >/dev/null 2>&1 || true
+    log_info "Running nuclei with $threads threads"
+    [[ -s "$subs_dir/live-subs.txt" ]] && nuclei -l "$subs_dir/live-subs.txt" -t nuclei_templates/Others -c "$threads" -o "$out1" >/dev/null 2>&1 || true
+    [[ -s "$subs_dir/live-subs.txt" ]] && nuclei -l "$subs_dir/live-subs.txt" -t nuclei-templates/http -c "$threads" -o "$out2" >/dev/null 2>&1 || true
   fi
 
   [[ -s "$out1" ]] && discord_send_file "$out1" "Nuclei custom template results"