💥 Remade all commands

Remade all commands for the pool.

internal/shodan/alert/clear.go

@@ -3,36 +3,48 @@ package alert
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"git.tcp.direct/perp/shogo/internal/utils"
 )
 
 // Clear all alerts
-func Clear() {
+func (a *Alert) Clear() {
 	// Get results
 	results, err := utils.Client.GetAlerts(context.Background())
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	utils.Title.Println("Clearing alerts...")
+	// Store lines
+	var lines string
+
+	// Add lines
+	lines += utils.Title.Sprintln("Clearing alerts...")
 
 	for index := range results {
 		// Set results
 		result, err := utils.Client.DeleteAlert(context.Background(), results[index].ID)
 		if err != nil {
-			fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+			a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 			return
 		}
 
-		// Print results
+		// Add lines
 		if result {
-			fmt.Printf("%s: %s\n", utils.Green("Deleted alert"), utils.Blue(results[index].ID))
+			lines += fmt.Sprintf(
+				"%s: %s\n",
+				utils.Green("Deleted alert"),
+				utils.Blue(results[index].ID),
+			)
 		} else {
-			fmt.Printf("%s: %s\n", utils.Red("Error"), "failed deleting an alert")
+			lines += fmt.Sprintf("%s: %s\n", utils.Red("Error"), "failed deleting an alert")
 		}
 	}
-}
 
-// Todo: Make this threaded
+	// Remove empty newline
+	lines = strings.TrimRight(lines, "\n")
+	// Send results
+	a.Results <- lines
+}

internal/shodan/alert/create.go

@@ -8,17 +8,23 @@ import (
 )
 
 // Create an alert
-func Create(name, ip string) {
+func (a *Alert) Create() {
-	host := []string{ip}
+	host := []string{a.IP}
 
 	// Get results
-	results, err := utils.Client.CreateAlert(context.Background(), name, host, 0)
+	results, err := utils.Client.CreateAlert(context.Background(), a.Name, host, 0)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Println("Successfully created alert!")
+	var lines string
-	fmt.Printf("%s: %s\n", utils.Green("Alert ID"), utils.Blue(results.ID))
+
+	// Add lines
+	lines += utils.Title.Sprintln("Successfully created alert!")
+	lines += fmt.Sprintf("%s: %s", utils.Green("Alert ID"), utils.Blue(results.ID))
+
+	// Send result
+	a.Results <- lines
 }

internal/shodan/alert/delete.go

@@ -8,18 +8,18 @@ import (
 )
 
 // Delete an alert
-func Delete(id string) {
+func (a *Alert) Delete() {
 	// Set results
-	results, err := utils.Client.DeleteAlert(context.Background(), id)
+	results, err := utils.Client.DeleteAlert(context.Background(), a.ID)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Send result
 	if results {
-		utils.Title.Println("Successfully deleted alert!")
+		a.Results <- utils.Title.Sprintf("Successfully deleted alert!")
 	} else {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), "alert does not exist")
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), "alert does not exist")
 	}
 }

internal/shodan/alert/info.go

@@ -9,21 +9,27 @@ import (
 )
 
 // Return alert information
-func Info(id string) {
+func (a *Alert) Info() {
 	// Get results
-	results, err := utils.Client.GetAlert(context.Background(), id)
+	results, err := utils.Client.GetAlert(context.Background(), a.ID)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Printf("Alert %s\n", id)
+	var lines string
-	fmt.Printf("%s: %s\n", utils.Green("Name"), utils.Blue(results.Name))
+
-	fmt.Printf(
+	// Add lines
+	lines += utils.Title.Sprintf("Alert %s\n", a.ID)
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("Name"), utils.Blue(results.Name))
+	lines += fmt.Sprintf(
 		"%s: %s\n",
 		utils.Blue("Network"),
 		utils.Green(strings.Join(results.Filters.IP, ",")),
 	)
-	fmt.Printf("%s: %s\n", utils.Green("Created"), utils.Blue(results.Created))
+	lines += fmt.Sprintf("%s: %s", utils.Green("Created"), utils.Blue(results.Created))
+
+	// Send results
+	a.Results <- lines
 }

internal/shodan/alert/list.go

@@ -9,23 +9,31 @@ import (
 )
 
 // Return all the active alerts
-func List() {
+func (a *Alert) List() {
 	// Get results
 	results, err := utils.Client.GetAlerts(context.Background())
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		a.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Printf("%s%13s%28s\n", "Alert ID", "Name", "IP/Network")
+	var lines string
+
+	// Add lines
+	lines += utils.Title.Sprintf("%s%13s%28s\n", "Alert ID", "Name", "IP/Network")
 
 	for index := range results {
-		fmt.Printf(
+		lines += fmt.Sprintf(
 			"%-14s %-24s %24s\n",
 			utils.Green(results[index].ID),
 			utils.Blue(results[index].Name),
 			utils.Green(strings.Join(results[index].Filters.IP, ",")),
 		)
 	}
+
+	// Remove empty newline
+	// Send results
+	lines = strings.TrimRight(lines, "\n")
+	a.Results <- lines
 }

internal/shodan/count.go

@@ -3,7 +3,6 @@ package shodan
 import (
 	"context"
 	"fmt"
-	"os"
 
 	"github.com/ns3777k/go-shodan/v4/shodan"
 
@@ -11,20 +10,19 @@ import (
 )
 
 // Return your query result count
-func Count(query string) {
+func (s *Shodan) Count() {
 	// Setup query
 	options := &shodan.HostQueryOptions{
-		Query: query,
+		Query: s.Flags.Query,
 	}
 
 	// Get results
 	results, err := utils.Client.GetHostsCountForQuery(context.Background(), options)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
-		os.Exit(1)
+		return
 	}
 
-	// Print results
+	// Send result
-	utils.Title.Printf("Count: %s\n", query)
+	s.Results <- utils.Title.Sprintf("Count: %s\n", s.Flags.Query) + fmt.Sprintf("%s", utils.Blue(results.Total))
-	fmt.Printf("%s\n", utils.Blue(results.Total))
 }

internal/shodan/domain.go

@@ -3,41 +3,27 @@ package shodan
 import (
 	"context"
 	"fmt"
-	"net"
-
-	"github.com/ns3777k/go-shodan/v4/shodan"
 
 	"git.tcp.direct/perp/shogo/internal/utils"
 )
 
 // Return domain information
-func Domain(host string) {
+func Domain(domain string) {
-	// Parse IP
-	ips, err := net.LookupIP(host)
-	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
-		return
-	}
-
 	// Get results
-	results, err := utils.Client.GetServicesForHost(
+	results, err := utils.Client.GetDomain(context.Background(), domain)
-		context.Background(),
-		ips[0].To4().String(),
-		&shodan.HostServicesOptions{},
-	)
 	if err != nil {
 		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
 		return
 	}
 
 	// Print results
-	utils.Title.Printf("Domain: %s", host)
+	utils.Title.Printf("Domain: %s", domain)
 
 	fmt.Printf("\n\n")
 
 	for index := range results.Data {
-		fmt.Println(results.Data[index].Domains)
+		fmt.Println(results.Data[index])
 	}
 }
 
-// Todo: Find domain records
+// Todo: Find domain records, add padding, add to pool

internal/shodan/host.go

@@ -11,49 +11,53 @@ import (
 )
 
 // Return host information
-func Host(ip string) {
+func (s *Shodan) Host() {
 	// Get results
 	results, err := utils.Client.GetServicesForHost(
 		context.Background(),
-		ip,
+		s.Flags.Query,
 		&shodan.HostServicesOptions{},
 	)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Alternate between colors
-	utils.Title.Printf("Host: %s\n", ip)
+	var alternate bool
-	fmt.Printf(
+	// Store lines
+	var lines string
+	// Store port/protocol/service
+	var port string
+
+	// Add lines
+	lines += utils.Title.Sprintf("Host: %s\n", s.Flags.Query)
+	lines += fmt.Sprintf(
 		"%s: %s\n",
 		utils.Green("Hostnames"),
 		utils.Blue(strings.Join(results.Hostnames, ",")),
 	)
-	fmt.Printf("%s: %s\n", utils.Blue("Organization"), utils.Green(results.Organization))
+	lines += fmt.Sprintf("%s: %s\n", utils.Blue("Organization"), utils.Green(results.Organization))
-	fmt.Printf("%s: %s\n", utils.Green("Country"), utils.Blue(results.Country))
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("Country"), utils.Blue(results.Country))
-	fmt.Printf("%s: %s\n", utils.Blue("City"), utils.Green(results.City))
+	lines += fmt.Sprintf("%s: %s\n", utils.Blue("City"), utils.Green(results.City))
-	fmt.Printf("%s: %s\n", utils.Green("Updated"), utils.Blue(results.LastUpdate))
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("Updated"), utils.Blue(results.LastUpdate))
-	fmt.Printf("%s: %s\n", utils.Blue("Port count"), utils.Green(len(results.Ports)))
+	lines += fmt.Sprintf("%s: %s\n", utils.Blue("Port count"), utils.Green(len(results.Ports)))
-	fmt.Printf("\n%s:\n", utils.Green("Ports"))
+	lines += fmt.Sprintf("\n%s:\n", utils.Green("Ports"))
-
-	// Color alternator & current line
-	var alternate bool
-	var line string
 
+	// Go through data
 	for index := range results.Data {
 		// Alternate between colors
-		// Find each port & transport
+		// Find port & transport
 		if alternate {
 			alternate = false
-			line = fmt.Sprintf(
+			port = fmt.Sprintf(
 				"\t%s/%s",
 				utils.Blue(results.Data[index].Port),
 				utils.Green(results.Data[index].Transport),
 			)
 		} else if !alternate {
 			alternate = true
-			line = fmt.Sprintf(
+			port = fmt.Sprintf(
 				"\t%s/%s",
 				utils.Green(results.Data[index].Port),
 				utils.Blue(results.Data[index].Transport),
@@ -63,13 +67,17 @@ func Host(ip string) {
 		// Find each product
 		if results.Data[index].Product != "" {
 			if alternate {
-				line = fmt.Sprintf("%s (%s)", line, utils.Green(results.Data[index].Product))
+				port = fmt.Sprintf("%s (%s)", port, utils.Green(results.Data[index].Product))
 			} else if !alternate {
-				line = fmt.Sprintf("%s (%s)", line, utils.Blue(results.Data[index].Product))
+				port = fmt.Sprintf("%s (%s)", port, utils.Blue(results.Data[index].Product))
 			}
 		}
 
-		// Print results
+		lines += port + "\n"
-		fmt.Println(line)
 	}
+
+	// Remove empty newline
+	// Send results
+	lines = strings.TrimRight(lines, "\n")
+	s.Results <- lines
 }

internal/shodan/info.go

@@ -8,34 +8,37 @@ import (
 )
 
 // Return your account information
-func Info(profile_enabled bool) {
+func (s *Shodan) Info() {
 	// Fetch API information
 	results, err := utils.Client.GetAPIInfo(context.Background())
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Println("API")
+	var lines string
-	fmt.Printf("%s: %s\n", utils.Green("Plan"), utils.Blue(results.Plan))
+	// Store profile name
-	fmt.Printf("%s: %s\n", utils.Blue("Query credits"), utils.Green(results.QueryCredits))
+	var name string
-	fmt.Printf("%s: %s\n", utils.Green("Scan credits"), utils.Blue(results.ScanCredits))
-	fmt.Printf("%s: %s\n", utils.Blue("Telnet"), utils.Green(results.Telnet))
-	fmt.Printf("%s: %s\n", utils.Green("HTTPS"), utils.Blue(results.HTTPS))
-	fmt.Printf("%s: %s\n", utils.Blue("Unlocked"), utils.Green(results.Unlocked))
 
-	// Fetch profile information
+	// Add lines
-	if profile_enabled {
+	lines += utils.Title.Sprintln("API")
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("Plan"), utils.Blue(results.Plan))
+	lines += fmt.Sprintf("%s: %s\n", utils.Blue("Query credits"), utils.Green(results.QueryCredits))
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("Scan credits"), utils.Blue(results.ScanCredits))
+	lines += fmt.Sprintf("%s: %s\n", utils.Blue("Telnet"), utils.Green(results.Telnet))
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("HTTPS"), utils.Blue(results.HTTPS))
+	lines += fmt.Sprintf("%s: %s", utils.Blue("Unlocked"), utils.Green(results.Unlocked))
+
+	// Profile enabled
+	if s.Flags.Profile {
+		// Fetch profile information
 		results, err := utils.Client.GetAccountProfile(context.Background())
 		if err != nil {
-			fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+			s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 			return
 		}
 
-		// Profile name
-		var name string
-
 		// Empty name
 		if results.Name == "" {
 			name = "?"
@@ -43,13 +46,18 @@ func Info(profile_enabled bool) {
 			name = results.Name
 		}
 
-		// Print results
+		// Add lines
-		fmt.Println("")
+		lines += "\n\n"
+		lines += utils.Title.Sprintln("Profile")
+		lines += fmt.Sprintf("%s: %s\n", utils.Green("Name"), utils.Blue(name))
+		lines += fmt.Sprintf("%s: %s\n", utils.Blue("Member"), utils.Green(results.Member))
+		lines += fmt.Sprintf("%s: %s\n", utils.Green("Credits"), utils.Blue(results.Credits))
+		lines += fmt.Sprintf("%s: %s", utils.Blue("Created"), utils.Green(results.Created))
 
-		utils.Title.Println("Profile")
+		// Send results
-		fmt.Printf("%s: %s\n", utils.Green("Name"), utils.Blue(name))
+		s.Results <- lines
-		fmt.Printf("%s: %s\n", utils.Blue("Member"), utils.Green(results.Member))
-		fmt.Printf("%s: %s\n", utils.Green("Credits"), utils.Blue(results.Credits))
-		fmt.Printf("%s: %s\n", utils.Blue("Created"), utils.Green(results.Created))
 	}
+
+	// Send results
+	s.Results <- lines
 }

internal/shodan/myip.go

@@ -8,14 +8,14 @@ import (
 )
 
 // Return your IP address
-func MyIp() {
+func (s *Shodan) MyIp() {
 	// Fetch IP address
 	results, err := utils.Client.GetMyIP(context.Background())
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Send line
-	fmt.Printf("%s\n", utils.Blue(results.String()))
+	s.Results <- fmt.Sprintf("%s", utils.Blue(results.String()))
 }

internal/shodan/scan/internet.go

@@ -9,18 +9,21 @@ import (
 )
 
 // Submit an internet scan
-func Internet(port int, protocol string) {
+func (s *Scan) Internet() {
 	// Get results
-	results, err := utils.Client.ScanInternet(context.Background(), port, protocol)
+	results, err := utils.Client.ScanInternet(context.Background(), s.Port, s.Protocol)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Printf("Scanning internet for %d %s\n", port, protocol)
+	var lines string
 
-	fmt.Printf("%s: %s\n", utils.Green("ID"), utils.Blue(results))
+	// Print results
+	lines += utils.Title.Sprintf("Scanning internet for %d %s\n", s.Port, s.Protocol)
+
+	lines += fmt.Sprintf("%s: %s\n", utils.Green("ID"), utils.Blue(results))
 
 	for {
 		time.Sleep(time.Second * 3)
@@ -28,14 +31,15 @@ func Internet(port int, protocol string) {
 		// Get results
 		results, err := utils.Client.GetScanStatus(context.Background(), results)
 		if err != nil {
-			fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+			s.Results <- fmt.Sprintf("%s: %s\n", utils.Red("Error"), err.Error())
 			return
 		}
 
 		// Get status
 		switch results.Status {
 		case "DONE":
-			fmt.Printf("%s: %s\n", utils.Blue("Status"), utils.Green(results.Status))
+			lines += fmt.Sprintf("%s: %s", utils.Blue("Status"), utils.Green(results.Status))
+			s.Results <- lines
 			return
 		}
 	}

internal/shodan/scan/protocols.go

@@ -3,23 +3,32 @@ package scan
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"git.tcp.direct/perp/shogo/internal/utils"
 )
 
 // Return protocols to scan
-func Protocols() {
+func (s *Scan) Protocols() {
 	// Get results
 	results, err := utils.Client.GetProtocols(context.Background())
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store liens
-	utils.Title.Println("Protocols")
+	var lines string
+
+	// Add lines
+	lines += utils.Title.Sprintln("Protocols")
 
 	for key, value := range results {
-		fmt.Printf("%-36s %s\n", utils.Green(key), utils.Blue(value))
+		lines += fmt.Sprintf("%-36s %s\n", utils.Green(key), utils.Blue(value))
 	}
+
+	// Remove empty newline
+	lines = strings.TrimRight(lines, "\n")
+	// Send results
+	s.Results <- lines
 }

internal/shodan/scan/submit.go

@@ -9,18 +9,21 @@ import (
 )
 
 // Submit a scan
-func Submit(ips []string) {
+func (s *Scan) Submit() {
 	// Get results
-	results, err := utils.Client.Scan(context.Background(), ips)
+	results, err := utils.Client.Scan(context.Background(), s.IPs)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 		return
 	}
 
-	// Print results
+	// Store lines
-	utils.Title.Printf("Starting scan for %s\n", ips)
+	var lines string
 
-	fmt.Printf(
+	// Add lines
+	lines += utils.Title.Sprintf("Starting scan for %s\n", s.IPs)
+
+	lines += fmt.Sprintf(
 		"%s: %s\n%s: %s\n%s: %s\n",
 		utils.Green("ID"),
 		utils.Blue(results.ID),
@@ -36,14 +39,15 @@ func Submit(ips []string) {
 		// Get results
 		results, err := utils.Client.GetScanStatus(context.Background(), results.ID)
 		if err != nil {
-			fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+			s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
 			return
 		}
 
 		// Get status
 		switch results.Status {
 		case "DONE":
-			fmt.Printf("%s: %s\n", utils.Blue("Status"), utils.Green(results.Status))
+			lines += fmt.Sprintf("%s: %s", utils.Blue("Status"), utils.Green(results.Status))
+			s.Results <- lines
 			return
 		}
 	}

internal/shodan/stats.go

@@ -3,6 +3,7 @@ package shodan
 import (
 	"context"
 	"fmt"
+	"strings"
 
 	"github.com/ns3777k/go-shodan/v4/shodan"
 
@@ -17,27 +18,52 @@ type Stats struct {
 }
 
 // Return facet stats on a search
-func (s *Stats) Stats() {
+func (s *Shodan) Stats() {
 	// Setup options
 	options := &shodan.HostQueryOptions{
-		Query:  s.Query,
+		Query:  s.Flags.Query,
-		Facets: "US",
+		Facets: s.Flags.Facets,
-		Page:   s.Page,
+		Page:   1,
 	}
 
 	// Get results
 	results, err := utils.Client.GetHostsForQuery(context.Background(), options)
 	if err != nil {
-		fmt.Printf("%s: %s\n", utils.Red("Error"), err.Error())
+		s.Results <- fmt.Sprintf("%s: %s", utils.Red("Error"), err.Error())
-		s.Results <- ""
 		return
 	}
 
-	// Print results
+	// Store lines
-	for host := range results.Matches {
+	var lines string
-		fmt.Println(results.Matches[host])
-	}
-	s.Results <- ""
-}
 
-// Todo: Fix this
+	// Split facets
+	splitted := strings.Split(s.Flags.Facets, ",")
+
+	// Go through splitted
+	for split := range splitted {
+		// Get facet & count
+		facet := strings.Split(splitted[split], ":")
+
+		// Add lines
+		lines += utils.Title.Sprintf(
+			"\nTop %s results for %s query with %s facet\n",
+			facet[1],
+			s.Flags.Query,
+			facet[0],
+		)
+
+		for index := range results.Facets[facet[0]] {
+			lines += fmt.Sprintf(
+				"%s: %s\n",
+				utils.Green(results.Facets[facet[0]][index].Value),
+				utils.Blue(results.Facets[facet[0]][index].Count),
+			)
+		}
+	}
+
+	// Remove empty newline(s)
+	// Send results
+	lines = strings.Replace(lines, "\n", "", 1)
+	lines = strings.TrimRight(lines, "\n")
+	s.Results <- lines
+}