Refactor whitespace in main.go, main_test.go, and wordlist-gen.go for improved readability and consistency. Cleaned up unnecessary blank lines and ensured proper formatting throughout the files.

Author: TMHSDigital

main.go

@@ -4,7 +4,7 @@
 //
 // IMPORTANT LEGAL NOTICE:
 // This tool is provided for educational and legitimate security testing purposes ONLY.
-// Usage of this tool against any domain without explicit permission from the domain 
+// Usage of this tool against any domain without explicit permission from the domain
 // owner may violate applicable local, national, and/or international laws.
 //
 // Users MUST:
@@ -82,7 +82,7 @@ func main() {
 		fmt.Println("Error: Concurrency level (-t) must be greater than 0")
 		os.Exit(1)
 	}
-	
+
 	if *timeoutMs <= 0 {
 		fmt.Println("Error: Timeout (-timeout) must be greater than 0")
 		os.Exit(1)
@@ -145,10 +145,10 @@ func main() {
 		if err := scanner.Err(); err != nil {
 			fmt.Printf("Error counting wordlist lines: %v\n", err)
 		}
-		
+
 		// Reset file position to beginning
 		file.Seek(0, 0)
-		
+
 		if *verbose {
 			fmt.Printf("Total wordlist entries: %d\n", totalWords)
 		}
@@ -174,12 +174,12 @@ func main() {
 					processed := atomic.LoadInt64(&processedWords)
 					found := atomic.LoadInt64(&foundSubdomains)
 					progress := float64(processed) / float64(totalWords) * 100
-					fmt.Printf("\rProgress: %.1f%% (%d/%d) | Found: %d ", 
+					fmt.Printf("\rProgress: %.1f%% (%d/%d) | Found: %d ",
 						progress, processed, totalWords, found)
 				}
 			}
 		}()
-		
+
 		// Clean up the progress goroutine when main() exits
 		defer func() {
 			done <- true
@@ -196,15 +196,15 @@ func main() {
 			for subdomainPrefix := range subdomains {
 				fullDomain := subdomainPrefix + "." + domain
 				var resolved bool
-				
+
 				if *testMode {
 					// In test mode, simulate DNS resolution without actual queries
 					resolved = simulateResolution(fullDomain, *testHitRate, *verbose)
 				} else {
 					// In normal mode, perform actual DNS resolution
 					resolved = resolveDomain(fullDomain, timeout, *dnsServer, *verbose)
 				}
-				
+
 				if resolved {
 					if *testMode {
 						fmt.Printf("Found (SIMULATED): %s\n", fullDomain)
@@ -230,7 +230,7 @@ func main() {
 
 	close(subdomains)
 	wg.Wait()
-	
+
 	// Final summary
 	if *verbose {
 		fmt.Printf("\nScan completed for %s\n", domain)
@@ -240,7 +240,7 @@ func main() {
 			fmt.Printf("simulated ")
 		}
 		fmt.Printf("subdomains\n")
-		
+
 		if *testMode {
 			fmt.Println("\nNOTE: Results were simulated and no actual DNS queries were performed.")
 			fmt.Println("This mode is intended for educational and testing purposes only.")
@@ -253,11 +253,11 @@ func main() {
 func simulateResolution(domain string, hitRate int, verbose bool) bool {
 	// Always resolve common subdomains for more realistic simulation
 	commonSubdomains := []string{
-		"www", "mail", "ftp", "blog", 
-		"api", "dev", "staging", "test", 
+		"www", "mail", "ftp", "blog",
+		"api", "dev", "staging", "test",
 		"admin", "portal", "app", "secure",
 	}
-	
+
 	for _, sub := range commonSubdomains {
 		if strings.HasPrefix(domain, sub+".") {
 			// Simulate a successful lookup for these common subdomains
@@ -270,10 +270,10 @@ func simulateResolution(domain string, hitRate int, verbose bool) bool {
 			return rand.Intn(100) < 90
 		}
 	}
-	
+
 	// For other subdomains, use the hit rate to determine if they resolve
 	result := rand.Intn(100) < hitRate
-	
+
 	if verbose {
 		fakeTiming := time.Duration(100+rand.Intn(500)) * time.Millisecond
 		if result {
@@ -283,7 +283,7 @@ func simulateResolution(domain string, hitRate int, verbose bool) bool {
 			fmt.Printf("Failed to resolve (SIMULATED): %s (Error: no such host) in %s\n", domain, fakeTiming)
 		}
 	}
-	
+
 	return result
 }
 
@@ -297,16 +297,16 @@ func resolveDomain(domain string, timeout time.Duration, dnsServer string, verbo
 			return d.DialContext(ctx, "udp", dnsServer)
 		},
 	}
-	
+
 	start := time.Now()
 	ips, err := resolver.LookupHost(context.Background(), domain)
 	elapsed := time.Since(start)
-	
+
 	if verbose && err == nil {
 		fmt.Printf("Resolved: %s (IP: %s) in %s\n", domain, ips[0], elapsed)
 	} else if verbose {
 		fmt.Printf("Failed to resolve: %s (Error: %v) in %s\n", domain, err, elapsed)
 	}
-	
+
 	return err == nil
-} 
+}

main_test.go

@@ -49,14 +49,14 @@ func TestResolveDomain(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got := resolveDomain(tt.domain, timeout)
-			
+
 			// Note: DNS results can be unpredictable depending on the network environment
 			// If this test fails, it might be due to network issues or DNS changes
 			if got != tt.expected {
-				t.Logf("Warning: DNS resolution result for %s was %v, expected %v", 
+				t.Logf("Warning: DNS resolution result for %s was %v, expected %v",
 					tt.domain, got, tt.expected)
 				t.Logf("This might be due to network conditions or DNS changes")
-				
+
 				// Commented out the actual failure to make the test more robust
 				// Uncomment to enforce strict testing
 				// t.Errorf("resolveDomain(%s) = %v, want %v", tt.domain, got, tt.expected)
@@ -74,10 +74,10 @@ func TestResolveDomainTimeout(t *testing.T) {
 
 	// Use a very short timeout that should cause the lookup to time out
 	veryShortTimeout := time.Millisecond * 1
-	
+
 	// This should time out and return false, regardless of whether the domain exists
 	result := resolveDomain("google.com", veryShortTimeout)
-	
+
 	// We expect this to time out and return false
 	// However, on some very fast networks, this might still succeed
 	if result == true {
@@ -97,20 +97,20 @@ func TestResolveDomainWithCustomDNS(t *testing.T) {
 
 	// Set a reasonable timeout for tests
 	timeout := time.Second * 2
-	
+
 	// Define DNS servers to test
 	dnsServers := []string{
-		"8.8.8.8:53",  // Google
-		"1.1.1.1:53",  // Cloudflare
+		"8.8.8.8:53", // Google
+		"1.1.1.1:53", // Cloudflare
 	}
-	
+
 	// A domain that should definitely resolve
 	testDomain := "google.com"
-	
+
 	for _, server := range dnsServers {
 		t.Run(fmt.Sprintf("DNS_Server_%s", server), func(t *testing.T) {
 			result := resolveDomain(testDomain, timeout, server, false)
-			
+
 			if !result {
 				t.Logf("Warning: Failed to resolve %s using DNS server %s", testDomain, server)
 				t.Logf("This might be due to network conditions or DNS configuration")
@@ -125,32 +125,32 @@ func TestResolveDomainWithCustomDNS(t *testing.T) {
 func TestDNSServerValidation(t *testing.T) {
 	// This test doesn't actually call any functions directly,
 	// but it checks the validation logic we'd want to apply to DNS server strings
-	
+
 	validServers := []string{
 		"8.8.8.8:53",
 		"1.1.1.1:53",
 		"192.168.1.1:53",
 		"[2001:4860:4860::8888]:53", // IPv6
 	}
-	
+
 	invalidServers := []string{
-		"8.8.8.8",      // Missing port
-		":53",          // Missing IP
-		"localhost",    // Not in IP:port format
-		"256.1.1.1:53", // Invalid IP
-		"1.1.1.1:99999" // Invalid port
+		"8.8.8.8",       // Missing port
+		":53",           // Missing IP
+		"localhost",     // Not in IP:port format
+		"256.1.1.1:53",  // Invalid IP
+		"1.1.1.1:99999", // Invalid port
 	}
-	
+
 	for _, server := range validServers {
 		if !strings.Contains(server, ":") {
 			t.Errorf("DNS server validation should pass for %s but would fail with our check", server)
 		}
 	}
-	
+
 	for _, server := range invalidServers {
 		if strings.Contains(server, ":") && server != ":53" {
 			t.Logf("Simple validation would pass for invalid server: %s", server)
 			t.Logf("Consider implementing more thorough validation")
 		}
 	}
-} 
+}

tools/wordlist-gen.go

@@ -1,5 +1,5 @@
 // Copyright (c) 2025 TM Hospitality Strategies
-// 
+//
 // Tool for generating custom wordlists for subdomain enumeration
 // Educational purposes only
 
@@ -64,23 +64,23 @@ func main() {
 	// Process domain-specific terms if provided
 	if *domainInfo != "" {
 		fmt.Printf("Extracting terms from domain: %s\n", *domainInfo)
-		
+
 		// Remove TLD and split by separators
 		domain := *domainInfo
-		
+
 		// Remove common TLDs
 		domain = strings.TrimSuffix(domain, ".com")
 		domain = strings.TrimSuffix(domain, ".org")
 		domain = strings.TrimSuffix(domain, ".net")
 		domain = strings.TrimSuffix(domain, ".edu")
 		domain = strings.TrimSuffix(domain, ".gov")
 		domain = strings.TrimSuffix(domain, ".io")
-		
+
 		// Split by common separators
 		parts := strings.FieldsFunc(domain, func(r rune) bool {
 			return r == '.' || r == '-' || r == '_'
 		})
-		
+
 		for _, part := range parts {
 			if len(part) > 2 && !addedWords[part] { // Only add if length > 2
 				fmt.Fprintln(writer, part)
@@ -94,27 +94,27 @@ func main() {
 	if *combineWith != "" {
 		prefixes := strings.Split(*combineWith, ",")
 		fmt.Printf("Combining with prefixes: %v\n", prefixes)
-		
+
 		// Create a temporary copy of addedWords to iterate over
 		wordsCopy := make([]string, 0, len(addedWords))
 		for word := range addedWords {
 			wordsCopy = append(wordsCopy, word)
 		}
-		
+
 		// Create combinations
 		for _, prefix := range prefixes {
 			prefix = strings.TrimSpace(prefix)
 			if prefix == "" {
 				continue
 			}
-			
+
 			// Add the prefix itself
 			if !addedWords[prefix] {
 				fmt.Fprintln(writer, prefix)
 				addedWords[prefix] = true
 				fmt.Printf("Added: %s\n", prefix)
 			}
-			
+
 			// Create combinations with existing words
 			for _, word := range wordsCopy {
 				combination := prefix + "-" + word
@@ -130,4 +130,4 @@ func main() {
 	// Count total words
 	fmt.Printf("\nWordlist generated at %s with %d unique entries\n", *outputFile, len(addedWords))
 	fmt.Println("\nNOTE: Only use this tool to generate wordlists for domains you have explicit permission to test.")
-} 
+}