Refactor: Handle zero-result scans efficiently across all modules and Discord bot

Author: h0tak88r

internal/modules/aem/aem.go

@@ -106,17 +106,15 @@ func DiscoverAEM(opts Options) ([]string, error) {
 	log.Printf("[AEM] Starting AEM discovery (native Go)...")
 	discovered := DiscoverAEMFromURLs(urls, client, opts.Threads)
 
-	// Always save discovered instances (even if empty)
-	discoveredFH, err := os.Create(discoveredFile)
-	if err == nil {
-		if len(discovered) > 0 {
+	// Save discovered instances (only if found - empty files handled by SendPhaseFiles)
+	if len(discovered) > 0 {
+		discoveredFH, err := os.Create(discoveredFile)
+		if err == nil {
 			for _, url := range discovered {
 				fmt.Fprintln(discoveredFH, url)
 			}
-		} else {
-			fmt.Fprintln(discoveredFH, "No AEM instances discovered.")
+			discoveredFH.Close()
 		}
-		discoveredFH.Close()
 	}
 
 	// Don't send individual discovery messages - will be sent in consolidated file from Run()
@@ -238,39 +236,22 @@ func Run(opts Options) (*Result, error) {
 	}
 	res.DiscoveredCount = len(discovered)
 
-	// Always create consolidated result file even if no instances discovered
+	// If no AEM instances discovered, save JSON and return (no file created — SendPhaseFiles sends message)
 	if len(discovered) == 0 {
 		log.Printf("[AEM] No AEM instances discovered")
 
-		// Create consolidated file with "no results" message
-		consolidatedFile := filepath.Join(outputDir, "aem-scan.txt")
-		consolidatedF, err := os.Create(consolidatedFile)
-		if err == nil {
-			defer consolidatedF.Close()
-			domain := opts.Domain
-			if domain == "" && opts.LiveHostsFile != "" {
-				domain = "targets"
-			}
-			fmt.Fprintf(consolidatedF, "AEM Scan Results for %s\n", domain)
-			fmt.Fprintf(consolidatedF, "========================================\n\n")
-			fmt.Fprintf(consolidatedF, "No AEM instances discovered.\n")
-		}
-		
-		// Save empty results to JSON
+		// Save empty results to JSON only
 		allResults := map[string]interface{}{
 			"discovered_count": 0,
 			"vulnerabilities":  0,
 			"discovered":       []string{},
 			"findings":         []Finding{},
-			"scan_time":       time.Now().Format(time.RFC3339),
+			"scan_time":        time.Now().Format(time.RFC3339),
 		}
 		if data, err := json.MarshalIndent(allResults, "", "  "); err == nil {
 			os.WriteFile(resultsFile, data, 0644)
 		}
 
-		// Webhook sending removed - files are sent via utils.SendPhaseFiles from phase functions
-		
-		
 		res.Duration = time.Since(startTime)
 		return res, nil
 	}

internal/modules/backup/backup.go

@@ -189,11 +189,6 @@ func Run(opts Options) (*Result, error) {
 		}
 	}
 
-	// Always write a message if no results found
-	if foundCount == 0 {
-		resultsFH.WriteString("No backup files found.\n")
-	}
-	
 	log.Printf("[INFO] Backup scan: Wrote %d backup URLs to results file: %s", foundCount, resultsFile)
 
 	res.Duration = time.Since(start)

internal/modules/depconfusion/depconfusion.go

@@ -357,8 +357,12 @@ func convertJSONToText(jsonFile, textFile string) error {
 	}
 
 	// Rewrite the JSON file to only contain vulnerable entries (clean up false positives at source)
-	if cleanJSON, marshalErr := json.MarshalIndent(vulnerable, "", "  "); marshalErr == nil {
-		os.WriteFile(jsonFile, cleanJSON, 0644)
+	if len(vulnerable) == 0 {
+		os.WriteFile(jsonFile, []byte{}, 0644) // Leave JSON file entirely empty
+	} else {
+		if cleanJSON, marshalErr := json.MarshalIndent(vulnerable, "", "  "); marshalErr == nil {
+			os.WriteFile(jsonFile, cleanJSON, 0644)
+		}
 	}
 
 	// Create text file
@@ -369,9 +373,7 @@ func convertJSONToText(jsonFile, textFile string) error {
 	defer f.Close()
 
 	if len(vulnerable) == 0 {
-		fmt.Fprintf(f, "=== Dependency Confusion Scan Results ===\n\n")
-		fmt.Fprintf(f, "No vulnerable packages found.\n")
-		return nil
+		return nil // Leave text file empty, do not write header or "No vulnerable packages found"
 	}
 
 	// Write header

internal/modules/dns/dns.go

@@ -537,17 +537,19 @@ func checkAzureAWS(domainDir, findingsDir, subsFile string) error {
 		return err
 	}
 
-	// Append simple summary to combo file
-	summary := []string{
-		"=== AZURE & AWS SUBDOMAIN TAKEOVER DETECTION SUMMARY ===",
-		"Scan Date: " + timeNowString(),
-		fmt.Sprintf("Total Subdomains Checked: %d", mustCount(subsFile)),
-		fmt.Sprintf("Azure Vulnerabilities Found: %d", azureCount),
-		fmt.Sprintf("AWS Vulnerabilities Found: %d", awsCount),
-		fmt.Sprintf("Total Vulnerabilities: %d", vulnCount),
-	}
-	if err := appendLines(comboOut, summary...); err != nil {
-		return err
+	// Append simple summary to combo file only if vulnerabilities were found
+	if vulnCount > 0 {
+		summary := []string{
+			"=== AZURE & AWS SUBDOMAIN TAKEOVER DETECTION SUMMARY ===",
+			"Scan Date: " + timeNowString(),
+			fmt.Sprintf("Total Subdomains Checked: %d", mustCount(subsFile)),
+			fmt.Sprintf("Azure Vulnerabilities Found: %d", azureCount),
+			fmt.Sprintf("AWS Vulnerabilities Found: %d", awsCount),
+			fmt.Sprintf("Total Vulnerabilities: %d", vulnCount),
+		}
+		if err := appendLines(comboOut, summary...); err != nil {
+			return err
+		}
 	}
 
 	// Send findings to webhook if configured

internal/modules/misconfig/misconfig.go

@@ -172,9 +172,6 @@ func handleScan(opts Options, resultsDir string) error {
 				return fmt.Errorf("failed to write result: %w", err)
 			}
 		}
-	} else {
-		// Write "no results" message to file
-		f.WriteString("No misconfiguration findings found.\n")
 	}
 
 	fmt.Printf("[OK] Misconfig scan completed for %s (%d findings)\n", opts.Target, len(allResults))

internal/modules/ports/ports.go

@@ -63,36 +63,14 @@ func ScanPorts(domain string, threads int) (*Result, error) {
 	count, err := naabutool.ScanFromFile(subsFile, threads, outFile)
 	if err != nil {
 		log.Printf("[WARN] Naabu scan failed: %v", err)
-		// Create empty file with "no results" message
-		if f, err := os.Create(outFile); err == nil {
-			f.WriteString("No open ports found (excluding ports 80, 443, 8080 and 8443).\n")
-			f.Close()
-		}
 		count = 0
-	} else {
-		// Check if file is empty and write "no results" message if so
-		if info, err := os.Stat(outFile); err == nil && info.Size() == 0 {
-			if f, err := os.OpenFile(outFile, os.O_WRONLY|os.O_APPEND, 0644); err == nil {
-				f.WriteString("No open ports found (excluding ports 80, 443, 8080 and 8443).\n")
-				f.Close()
-			}
-		}
 	}
 	log.Printf("[OK] Port scan completed, found %d open ports", count)
 
 	// Send result files to Discord webhook if configured (only when not running under bot)
 	// When running under bot (AUTOAR_CURRENT_SCAN_ID is set), the bot handles R2 upload and zip link
 	if os.Getenv("AUTOAR_CURRENT_SCAN_ID") == "" {
-		webhookURL := os.Getenv("DISCORD_WEBHOOK")
-		if webhookURL != "" {
-			// Send ports.txt if it exists and has content
-			if info, err := os.Stat(outFile); err == nil && info.Size() > 0 {
-				utils.SendWebhookFileAsync(outFile, fmt.Sprintf("Port Scan Results: %d open ports found for %s", count, domain))
-			} else if count == 0 {
-				// Send "no findings" message if no ports found
-				utils.SendWebhookLogAsync(fmt.Sprintf("Port scan completed for %s: 0 open ports found (excluding ports 80, 443, 8080 and 8443)", domain))
-			}
-		}
+		utils.SendPhaseFiles("ports", domain, []string{outFile})
 	}
 
 	return &Result{

internal/modules/tech/tech.go

@@ -87,11 +87,7 @@ func DetectTech(domain string, threads int) (*Result, error) {
 	}
 
 	if len(targets) == 0 {
-		log.Printf("[WARN] No live hosts found; creating empty tech file for %s", domain)
-		if f, err := os.Create(outFile); err == nil {
-			f.WriteString("No live hosts found for technology detection.\n")
-			f.Close()
-		}
+		log.Printf("[WARN] No live hosts found for %s; skipping tech detection", domain)
 		return &Result{
 			Domain:     domain,
 			Hosts:      0,

internal/modules/utils/discord.go

@@ -76,11 +76,7 @@ func SendPhaseFiles(phaseName, domain string, filePaths []string) error {
 
 	if len(existingFiles) == 0 {
 		log.Printf("[DEBUG] [DISCORD] No valid files to send for phase %s", phaseName)
-		// Send a short ⚪ message indicating 0 findings
-		msg := fmt.Sprintf("⚪ **%s** — 0 findings", phaseName)
-		if domain != "" {
-			msg = fmt.Sprintf("⚪ **%s** — 0 findings for `%s`", phaseName, domain)
-		}
+		msg := phaseNoResultsMessage(phaseName, domain)
 		SendWebhookLogAsync(msg)
 		return nil
 	}
@@ -416,3 +412,51 @@ func GetPhaseFiles(phaseName, domain string) []string {
 	return files
 }
 
+// phaseNoResultsMessage returns a styled Discord message for a phase that yielded zero results
+func phaseNoResultsMessage(phaseName, domain string) string {
+	target := domain
+	if target == "" {
+		target = "targets"
+	} else {
+		target = "`" + target + "`"
+	}
+
+	switch phaseName {
+	case "ports":
+		return fmt.Sprintf("[ ⚪ ] **Port Scan** — No open ports found (excluding 80, 443, 8080, 8443) for %s", target)
+	case "aem", "aem_scan":
+		return fmt.Sprintf("[ ⚪ ] **AEM Scan** — No AEM instances discovered for %s", target)
+	case "tech":
+		return fmt.Sprintf("[ ⚪ ] **Tech Detection** — No live hosts found for %s", target)
+	case "backup":
+		return fmt.Sprintf("[ ⚪ ] **Backup Scan** — No backup files found for %s", target)
+	case "misconfig":
+		return fmt.Sprintf("[ ⚪ ] **Misconfig Scan** — No misconfigurations found for %s", target)
+	case "subdomains":
+		return fmt.Sprintf("[ ⚪ ] **Subdomains** — No subdomains found for %s", target)
+	case "livehosts":
+		return fmt.Sprintf("[ ⚪ ] **Live Hosts** — No live hosts found for %s", target)
+	case "urls":
+		return fmt.Sprintf("[ ⚪ ] **URLs** — No interesting URLs found for %s", target)
+	case "jsscan", "js":
+		return fmt.Sprintf("[ ⚪ ] **JS Scan** — No JavaScript vulnerabilities found for %s", target)
+	case "nuclei":
+		return fmt.Sprintf("[ ⚪ ] **Nuclei** — No vulnerabilities found for %s", target)
+	case "gf":
+		return fmt.Sprintf("[ ⚪ ] **GF Patterns** — No vulnerable parameters found for %s", target)
+	case "s3":
+		return fmt.Sprintf("[ ⚪ ] **S3 Scan** — No exposed buckets found for %s", target)
+	case "githubscan":
+		return fmt.Sprintf("[ ⚪ ] **GitHub Scan** — No secrets found for %s", target)
+	case "zerodays", "0days":
+		return fmt.Sprintf("[ ⚪ ] **0-Days** — No zero-day vulnerabilities found for %s", target)
+	case "ffuf":
+		return fmt.Sprintf("[ ⚪ ] **Fuzzing** — No hidden directories found for %s", target)
+	default:
+		name := phaseName
+		if len(phaseName) > 0 {
+			name = strings.ToUpper(string(phaseName[0])) + phaseName[1:]
+		}
+		return fmt.Sprintf("[ ⚪ ] **%s** — 0 findings for %s", name, target)
+	}
+}