feat: add debug flag and refactor CLI for improved target processing

Author: root4loot

README.md

@@ -27,10 +27,11 @@ docker run --rm -it $(docker build -q .) example.com
 ## Usage
 
 ```bash
-Usage: crtsher [options] <domain | orgname>
+Usage: crtsher [options] <domain | orgname> 
   -f, --file <file>           Specify input file containing targets, one per line.
   -t, --timeout <seconds>     Set the timeout for each request (default: 90).
   -c, --concurrency <number>  Set the number of concurrent requests (default: 3).
+      --debug                 Enable debug mode.
       --version               Display the version information.
       --help                  Display this help message.
 

cmd/crtsher/main.go

@@ -4,8 +4,10 @@ import (
 	"bufio"
 	"flag"
 	"fmt"
+	"io"
 	"os"
 	"strings"
+	"sync"
 
 	"github.com/root4loot/crtsher"
 	"github.com/root4loot/goutils/domainutil"
@@ -22,11 +24,28 @@ func init() {
 	log.Init(AppName)
 }
 
+type CLI struct {
+	Target      string
+	Concurrency int
+	Infile      string
+	Timeout     int
+	Debug       bool
+}
+
+func NewCLI() *CLI {
+	return &CLI{
+		Concurrency: 3,
+		Timeout:     90,
+	}
+}
+
+// TODO: implement debug flag
 const usage = `
 Usage: crtsher [options] <domain | orgname> 
   -f, --file <file>           Specify input file containing targets, one per line.
   -t, --timeout <seconds>     Set the timeout for each request (default: 90).
   -c, --concurrency <number>  Set the number of concurrent requests (default: 3).
+      --debug                 Enable debug mode.
       --version               Display the version information.
       --help                  Display this help message.
 
@@ -41,39 +60,103 @@ Examples:
 `
 
 func main() {
-	inputList, opts, err := parseCLI()
-	runner := crtsher.NewRunnerWithOptions(opts)
-
-	if err != nil {
-		if err.Error() == "version" {
-			fmt.Println("version:", Version)
-			os.Exit(0)
-		}
+	cli := NewCLI()
+	cli.parseFlags()
+	flag.Parse()
 
-		log.Error(err)
+	if len(flag.Args()) == 0 && !hasStdin() && cli.Infile == "" {
+		log.Error("No targets specified. Please provide a domain or organization name.")
+		fmt.Print(usage)
 		os.Exit(0)
 	}
 
+	targetChannel := make(chan string)
+
+	go cli.processTargets(targetChannel)
+	cli.processTarget(targetChannel) // Directly call without a done channel
+}
+
+func (cli *CLI) processTargets(targetChannel chan<- string) {
+	args := flag.Args()
+
+	if len(args) > 0 {
+		log.Debug("Processing command line arguments")
+		for _, target := range args {
+			targetChannel <- target
+		}
+	}
+
 	if hasStdin() {
-		log.Debug("Reading from stdin")
+		log.Debug("Reading targets from standard input")
+		cli.processInput(os.Stdin, targetChannel)
+	}
+
+	if cli.Infile != "" {
+		log.Debugf("Reading targets from file: %s", cli.Infile)
+		cli.processFileTargets(cli.Infile, targetChannel)
+	}
+
+	close(targetChannel)
+}
 
-		scanner := bufio.NewScanner(os.Stdin)
-		for scanner.Scan() {
-			inputList = append(inputList, strings.TrimSpace(scanner.Text()))
+func (cli *CLI) processInput(input io.Reader, targetChannel chan<- string) {
+	scanner := bufio.NewScanner(input)
+	for scanner.Scan() {
+		for _, target := range strings.Fields(scanner.Text()) {
+			targetChannel <- target
 		}
 	}
 
-	if inputList != nil {
-		processResults(runner, inputList...)
+	if err := scanner.Err(); err != nil {
+		log.Error("Error reading input:", err)
+		os.Exit(1)
+	}
+}
+
+func (cli *CLI) processTarget(targetChannel <-chan string) {
+	sem := make(chan struct{}, cli.Concurrency)
+	var wg sync.WaitGroup
+
+	for target := range targetChannel {
+		log.Debug("Processing CLI target:", target)
+		sem <- struct{}{}
+		wg.Add(1)
+		go func(t string) {
+			defer func() { <-sem }()
+			defer wg.Done()
+			results := cli.worker(t)
+			cli.processResults(results)
+		}(target)
 	}
 
+	wg.Wait()
+}
+
+func (cli *CLI) processFileTargets(infile string, targetChannel chan<- string) {
+	fileTargets, err := fileutil.ReadFile(infile)
+	if err != nil {
+		log.Error("Error reading file:", err)
+		close(targetChannel)
+		os.Exit(1)
+	}
+	for _, target := range fileTargets {
+		targetChannel <- target
+	}
 }
 
-func processResults(runner *crtsher.Runner, target ...string) {
-	go runner.RunMultipleAsync(target)
+func (cli *CLI) worker(target string) []crtsher.Result {
+	crtsherRunner := crtsher.NewRunner()
+	crtsherRunner.Options.Concurrency = cli.Concurrency
+	crtsherRunner.Options.Timeout = cli.Timeout
+	log.Debugf("Starting query for target: %s", target)
+	results := crtsherRunner.Query(target)
+	log.Debugf("Finished query for target: %s", target)
+	return results
+}
 
+func (cli *CLI) processResults(results []crtsher.Result) {
 	printed := make(map[string]bool)
-	for res := range runner.Results {
+	for _, res := range results {
 		res.CommonName = strings.ToLower(res.CommonName)
 		res.CommonName = strings.TrimPrefix(res.CommonName, "*.")
 		res.IssuerName = strings.ToLower(res.IssuerName)
@@ -93,69 +176,47 @@ func processResults(runner *crtsher.Runner, target ...string) {
 	}
 }
 
-func parseCLI() ([]string, *crtsher.Options, error) {
-	var version, help bool
-	var inputFilePath string
-	var inputList []string
+func (cli *CLI) parseFlags() {
+	var help, ver, debug bool
 
 	opts := *crtsher.DefaultOptions()
 
-	flag.StringVar(&inputFilePath, "f", "", "")
-	flag.StringVar(&inputFilePath, "file", "", "")
-	flag.IntVar(&opts.Timeout, "timeout", opts.Timeout, "")
-	flag.IntVar(&opts.Timeout, "t", opts.Timeout, "")
-	flag.IntVar(&opts.Concurrency, "concurrency", opts.Concurrency, "")
-	flag.IntVar(&opts.Concurrency, "c", opts.Concurrency, "")
-	flag.BoolVar(&version, "version", false, "")
-	flag.BoolVar(&help, "help", false, "")
-	flag.Usage = func() {
-		fmt.Fprint(os.Stdout, usage)
+	setStringFlag := func(name, shorthand, value, usage string) {
+		flag.StringVar(&cli.Infile, name, value, usage)
+		flag.StringVar(&cli.Infile, shorthand, value, usage)
 	}
-	flag.Parse()
 
-	args := flag.Args()
-	if len(args) > 0 {
-		inputList = args
+	setIntFlag := func(name, shorthand string, value int, usage string) {
+		flag.IntVar(&cli.Timeout, name, value, usage)
+		flag.IntVar(&cli.Timeout, shorthand, value, usage)
 	}
 
-	if inputFilePath != "" {
-		lines, err := fileutil.ReadFile(inputFilePath)
-		if err != nil {
-			return nil, nil, err
-		}
+	setStringFlag("file", "f", "", "")
+	setIntFlag("timeout", "t", opts.Timeout, "")
+	setIntFlag("concurrency", "c", opts.Concurrency, "")
 
-		inputList = append(inputList, lines...)
-	}
+	flag.BoolVar(&debug, "debug", false, "")
+	flag.BoolVar(&ver, "version", false, "")
+	flag.BoolVar(&help, "help", false, "")
 
-	if help || version || (len(flag.Args()) == 0 && len(inputList) == 0 && !hasStdin()) {
-		if help {
-			fmt.Fprint(os.Stdout, usage)
-			return nil, nil, nil
-		} else if version {
-			log.Info("Version:", Version)
-		} else {
-			return nil, nil, fmt.Errorf("No input provided. See -h for usage")
-		}
+	flag.Usage = func() {
+		fmt.Fprint(os.Stdout, usage)
 	}
+	flag.Parse()
 
-	if log.IsOutputPiped() {
-		log.Notify(log.PipedOutputNotification)
+	if debug {
+		log.SetLevel(log.DebugLevel)
 	}
 
-	if hasStdin() {
-		inputList = append(inputList, processStdin()...)
+	if help {
+		fmt.Print(usage)
+		os.Exit(0)
 	}
 
-	if inputFilePath != "" {
-		lines, err := fileutil.ReadFile(inputFilePath)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		inputList = append(inputList, lines...)
+	if ver {
+		fmt.Println(AppName, Version)
+		os.Exit(0)
 	}
-
-	return inputList, &opts, nil
 }
 
 func hasStdin() bool {
@@ -165,22 +226,9 @@ func hasStdin() bool {
 	}
 
 	mode := stat.Mode()
+
 	isPipedFromChrDev := (mode & os.ModeCharDevice) == 0
 	isPipedFromFIFO := (mode & os.ModeNamedPipe) != 0
 
 	return isPipedFromChrDev || isPipedFromFIFO
 }
-
-func processStdin() []string {
-	var targets []string
-	if hasStdin() {
-		scanner := bufio.NewScanner(os.Stdin)
-		for scanner.Scan() {
-			line := strings.TrimSpace(scanner.Text())
-			if len(line) > 0 {
-				targets = append(targets, strings.Fields(line)...)
-			}
-		}
-	}
-	return targets
-}

example/example.go

@@ -9,10 +9,8 @@ import (
 func main() {
 	runner := crtsher.NewRunner()
 
-	results := runner.Run("example.com")
+	results := runner.Query("example.com")
 	for _, result := range results {
-		if result.GetCommonName() != "" {
-			fmt.Println(result.GetCommonName())
-		}
+		fmt.Println(result.GetCommonName())
 	}
 }