committing, code is unworking and mid refactor

cmd/kyoketsu-web/kyoketsu-web.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"os"
+
+	kyoketsu "git.aetherial.dev/aeth/kyoketsu/pkg"
+)
+
+func main() {
+	kyoketsu.RefactorGetAllRemAddr(os.Args[1])
+
+}

cmd/kyoketsu/kyoketsu.go

@@ -1,10 +1,12 @@
 package main
 
 import (
+	"encoding/json"
 	"flag"
 	"fmt"
 	"log"
 	"net"
+	"os"
 	"strings"
 	"sync"
 
@@ -12,8 +14,6 @@ import (
 )
 
 func main() {
-	//	kyoketsu.PingWithDependency(os.Args[1])
-	//	os.Exit(1)
 
 	local := flag.Bool("local", true, "set flag to false to run this in targeted remote mode")
 	remoteAddrs := flag.String("ips", "", "comma seperated list of ip addresses to gather info about")
@@ -22,10 +22,16 @@ func main() {
 
 	if !*local {
 		spAddr := strings.Split(*remoteAddrs, ",")
-		addr, err := kyoketsu.GetAllRemoteAddresses(spAddr)
+		addr, err := kyoketsu.GetAllRemoteAddresses(spAddr, 65535)
 		if err != nil {
 			log.Fatal(err)
 		}
+		b, err := json.Marshal(addr)
+		if err != nil {
+			log.Fatal(err)
+		}
+		os.WriteFile("test/slash16_ips.json", b, os.ModePerm)
+
 		log.Printf("Starting scan on %v devices.\n", len(addr.Addr))
 		var wg sync.WaitGroup
 		for i := range addr.Addr {
@@ -48,7 +54,7 @@ func main() {
 		wg.Wait()
 
 	} else {
-		addr, err := kyoketsu.GetAllAddresses(*iface)
+		addr, err := kyoketsu.GetAllAddresses(*iface, 65535)
 		if err != nil {
 			log.Fatal(err)
 		}

go.mod

@@ -5,6 +5,7 @@ go 1.21.1
 require (
 	github.com/go-ping/ping v1.1.0 // indirect
 	github.com/golang/snappy v0.0.1 // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/uuid v1.2.0 // indirect
 	github.com/klauspost/compress v1.13.6 // indirect
 	github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe // indirect

go.sum

@@ -2,6 +2,8 @@ github.com/go-ping/ping v1.1.0 h1:3MCGhVX4fyEUuhsfwPrsEdQw6xspHkv5zHsiSoDFZYw=
 github.com/go-ping/ping v1.1.0/go.mod h1:xIFjORFzTxqIV/tDVGO4eDy/bLuSyawEeojSm3GfRGk=
 github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/klauspost/compress v1.13.6 h1:P76CopJELS0TiO2mebmnzgWaajssP/EszplttgQxcgc=

pkg/local.go

@@ -19,25 +19,41 @@ func (n *NetworkInterfaceNotFound) Error() string {
 	return fmt.Sprintf("Interface: '%s' not found.", n.Passed)
 }
 
+func getNextAddr(addr net.IP) (net.IP, error) {
+	next, err := netip.ParseAddr(addr.String())
+	if err != nil {
+		return nil, err
+	}
+	return net.ParseIP(next.Next().String()), nil
+}
+
 /*
 Recursive function to get all of the IPv4 addresses for each IPv4 network that the host is on
 
 	:param addr: the address to recursively find the next address for
 	:param out: a pointer to a struct containing a list of addresses
 */
-func addressRecurse(addr netip.Addr, out *AllAddress) {
+func addressRecurse(ipmap *IpSubnetMapper, max int) {
-	ref := net.ParseIP(addr.String())
+
-	next := net.ParseIP(addr.Next().String())
+	if len(ipmap.Ipv4s) > max {
-	v, err := netip.ParseAddr(next.String())
+		return
+	}
+	next, err := getNextAddr(ipmap.NetworkAddr)
 	if err != nil {
-		log.Fatal(err)
+		log.Println(err)
+		return
 	}
-
+	ip, net, err := net.ParseCIDR(next.String())
-	if ref.Mask(ref.DefaultMask()).String() == next.Mask(next.DefaultMask()).String() {
+	if err != nil {
-		out.Addr = append(out.Addr, next)
+		log.Println(err)
-		addressRecurse(v, out)
+		return
+	}
+	if ip.Mask(net.Mask).String() != ipmap.NetworkAddr.String() {
+		return
 	}
 
+	ipmap.Ipv4s = append(ipmap.Ipv4s, next)
+	addressRecurse(ipmap, max)
 }
 
 /*
@@ -62,7 +78,7 @@ func getAddressByInterface(name string) ([]net.Addr, error) {
 Utilized a recursive function to find all addresses in the address space that the host belongs.
 Returns a pointer to an AllAddresses struct who has a list of net.IP structs inside
 */
-func GetAllAddresses(name string) (*AllAddress, error) {
+func GetAllAddresses(name string, maxDepth int) (*AllAddress, error) {
 	addresses, err := getAddressByInterface(name)
 	if err != nil {
 		return nil, err
@@ -77,7 +93,7 @@ func GetAllAddresses(name string) (*AllAddress, error) {
 		if root.IsLoopback() {
 			continue
 		}
-		addressRecurse(root, out)
+		// addressRecurse(ip, ip, out, maxDepth)
 	}
 	return out, nil
 }
@@ -86,11 +102,15 @@ func GetAllAddresses(name string) (*AllAddress, error) {
 Utilized a recursive function to find all addresses in the address space that the host belongs.
 Returns a pointer to an AllAddresses struct who has a list of net.IP structs inside
 */
-func GetAllRemoteAddresses(addrs []string) (*AllAddress, error) {
+func GetAllRemoteAddresses(addrs []string, maxDepth int) (*AllAddress, error) {
 	out := &AllAddress{}
 	var addresses []net.IP
 	for i := range addrs {
-		addresses = append(addresses, net.ParseIP(addrs[i]))
+		ip, _, err := net.ParseCIDR(addrs[i])
+		if err != nil {
+			return nil, err
+		}
+		addresses = append(addresses, ip)
 	}
 
 	for idx := range addresses {
@@ -103,8 +123,33 @@ func GetAllRemoteAddresses(addrs []string) (*AllAddress, error) {
 		if root.IsLoopback() {
 			continue
 		}
-		addressRecurse(root, out)
+		// addressRecurse(ip, ip, out, maxDepth)
 
 	}
 	return out, nil
 }
+
+type IpSubnetMapper struct {
+	Ipv4s       []net.IP
+	NetworkAddr net.IP
+	Mask        net.IPMask
+}
+
+func RefactorGetAllRemAddr(addr string) (*AllAddress, error) {
+	//	out := &AllAddress{}
+	ipmap := &IpSubnetMapper{Ipv4s: []net.IP{}}
+	ip, net, err := net.ParseCIDR(addr)
+	if err != nil {
+		return nil, err
+	}
+	ipmap.NetworkAddr = ip.Mask(net.Mask)
+	ipmap.Mask = ip.DefaultMask()
+	fmt.Printf("%+v\n", ip.Mask(net.Mask))
+	fmt.Println(ip.DefaultMask())
+	fmt.Printf("%s\n", net.IP.DefaultMask())
+
+	addressRecurse(ipmap, 2000)
+
+	return nil, nil
+
+}

pkg/local_test.go

@@ -0,0 +1,61 @@
+package kyoketsu
+
+import (
+	"encoding/json"
+	"log"
+	"net/netip"
+	"os"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func LoadTestAddresses(loc string) *AllAddress {
+	b, err := os.ReadFile(loc)
+	if err != nil {
+		log.Fatal("Test setup failed.\n", err)
+	}
+	var alladdr AllAddress
+	err = json.Unmarshal(b, &alladdr)
+	if err != nil {
+		log.Fatal("test setup failed.\n", err)
+	}
+	return &alladdr
+
+}
+
+// Testing the addres recursion function to return all IPs in the target address subnet
+func TestAddressRecurse(t *testing.T) {
+	type TestCase struct {
+		Name       string
+		Wants      *AllAddress
+		Input      string
+		ShouldFail bool
+	}
+
+	tc := []TestCase{
+		TestCase{
+			Name:  "Passing testcase with valid IP address, returns all addresses.",
+			Wants: LoadTestAddresses("../test/local_ips.json"),
+			Input: "192.168.50.50",
+		},
+		TestCase{
+			Name:  "Passing testcase with valid IP address that belongs to a /16 subnet",
+			Wants: LoadTestAddresses("../test/slash16_ips.json"),
+			Input: "10.252.1.0",
+		},
+	}
+	for i := range tc {
+		addr, err := netip.ParseAddr(tc[i].Input)
+		if err != nil {
+			t.Errorf("Test case: '%s' failed! Reason: %s", tc[i].Name, err)
+		}
+		got := &AllAddress{}
+		addressRecurse(addr, got, 65535)
+		if !cmp.Equal(got, tc[i].Wants) {
+			t.Errorf("Test case: '%s' failed! Got: %+v\nWant: %+v\n", tc[i].Name, got, tc[i].Wants)
+		}
+
+	}
+
+}

pkg/scanner.go

@@ -39,36 +39,27 @@ Perform a concurrent TCP port dial on a host, either by domain name or IP.
 */
 func PortWalk(addr string, portmap map[int]string) *Host {
 	wg := &sync.WaitGroup{}
-	out := make(chan *PortScanResult)
+	out := []*PortScanResult{}
-
+
-	wgOuter := &sync.WaitGroup{}
+	ports := RetrieveScanDirectives()
-	wgOuter.Add(1)
+	for p, s := range ports.Pairs {
-	go func() {
+		wg.Add(1)
-		defer wgOuter.Done()
+		port := p
-		ports := RetrieveScanDirectives()
+		svcs := s
-		for p, s := range ports.Pairs {
+		go func() {
-			wg.Add(1)
+			defer wg.Done()
-			port := p
+			out = append(out, singlePortScan(addr, port, svcs))
-			svcs := s
+		}()
-			go func() {
+	}
-				out <- singlePortScan(addr, port, svcs)
+	wg.Wait()
-				wg.Done()
-			}()
-		}
-		wg.Wait()
-		close(out)
-
-	}()
-
 	host := &Host{IpAddress: addr, ListeningPorts: []map[int]string{}}
-	for result := range out {
+	for i := range out {
-		if result.Listening {
+		if out[i].Listening {
 			host.ListeningPorts = append(host.ListeningPorts, map[int]string{
-				result.PortNumber: result.Service,
+				out[i].PortNumber: out[i].Service,
 			})
 		}
 	}
-	wgOuter.Wait()
 	return host
 
 }

pkg/scanner_test.go

@@ -0,0 +1 @@
+package kyoketsu

test/local_ips.json

@@ -0,0 +1,259 @@
+{
+  "addresses": [
+    "192.168.50.1",
+    "192.168.50.2",
+    "192.168.50.3",
+    "192.168.50.4",
+    "192.168.50.5",
+    "192.168.50.6",
+    "192.168.50.7",
+    "192.168.50.8",
+    "192.168.50.9",
+    "192.168.50.10",
+    "192.168.50.11",
+    "192.168.50.12",
+    "192.168.50.13",
+    "192.168.50.14",
+    "192.168.50.15",
+    "192.168.50.16",
+    "192.168.50.17",
+    "192.168.50.18",
+    "192.168.50.19",
+    "192.168.50.20",
+    "192.168.50.21",
+    "192.168.50.22",
+    "192.168.50.23",
+    "192.168.50.24",
+    "192.168.50.25",
+    "192.168.50.26",
+    "192.168.50.27",
+    "192.168.50.28",
+    "192.168.50.29",
+    "192.168.50.30",
+    "192.168.50.31",
+    "192.168.50.32",
+    "192.168.50.33",
+    "192.168.50.34",
+    "192.168.50.35",
+    "192.168.50.36",
+    "192.168.50.37",
+    "192.168.50.38",
+    "192.168.50.39",
+    "192.168.50.40",
+    "192.168.50.41",
+    "192.168.50.42",
+    "192.168.50.43",
+    "192.168.50.44",
+    "192.168.50.45",
+    "192.168.50.46",
+    "192.168.50.47",
+    "192.168.50.48",
+    "192.168.50.49",
+    "192.168.50.50",
+    "192.168.50.51",
+    "192.168.50.52",
+    "192.168.50.53",
+    "192.168.50.54",
+    "192.168.50.55",
+    "192.168.50.56",
+    "192.168.50.57",
+    "192.168.50.58",
+    "192.168.50.59",
+    "192.168.50.60",
+    "192.168.50.61",
+    "192.168.50.62",
+    "192.168.50.63",
+    "192.168.50.64",
+    "192.168.50.65",
+    "192.168.50.66",
+    "192.168.50.67",
+    "192.168.50.68",
+    "192.168.50.69",
+    "192.168.50.70",
+    "192.168.50.71",
+    "192.168.50.72",
+    "192.168.50.73",
+    "192.168.50.74",
+    "192.168.50.75",
+    "192.168.50.76",
+    "192.168.50.77",
+    "192.168.50.78",
+    "192.168.50.79",
+    "192.168.50.80",
+    "192.168.50.81",
+    "192.168.50.82",
+    "192.168.50.83",
+    "192.168.50.84",
+    "192.168.50.85",
+    "192.168.50.86",
+    "192.168.50.87",
+    "192.168.50.88",
+    "192.168.50.89",
+    "192.168.50.90",
+    "192.168.50.91",
+    "192.168.50.92",
+    "192.168.50.93",
+    "192.168.50.94",
+    "192.168.50.95",
+    "192.168.50.96",
+    "192.168.50.97",
+    "192.168.50.98",
+    "192.168.50.99",
+    "192.168.50.100",
+    "192.168.50.101",
+    "192.168.50.102",
+    "192.168.50.103",
+    "192.168.50.104",
+    "192.168.50.105",
+    "192.168.50.106",
+    "192.168.50.107",
+    "192.168.50.108",
+    "192.168.50.109",
+    "192.168.50.110",
+    "192.168.50.111",
+    "192.168.50.112",
+    "192.168.50.113",
+    "192.168.50.114",
+    "192.168.50.115",
+    "192.168.50.116",
+    "192.168.50.117",
+    "192.168.50.118",
+    "192.168.50.119",
+    "192.168.50.120",
+    "192.168.50.121",
+    "192.168.50.122",
+    "192.168.50.123",
+    "192.168.50.124",
+    "192.168.50.125",
+    "192.168.50.126",
+    "192.168.50.127",
+    "192.168.50.128",
+    "192.168.50.129",
+    "192.168.50.130",
+    "192.168.50.131",
+    "192.168.50.132",
+    "192.168.50.133",
+    "192.168.50.134",
+    "192.168.50.135",
+    "192.168.50.136",
+    "192.168.50.137",
+    "192.168.50.138",
+    "192.168.50.139",
+    "192.168.50.140",
+    "192.168.50.141",
+    "192.168.50.142",
+    "192.168.50.143",
+    "192.168.50.144",
+    "192.168.50.145",
+    "192.168.50.146",
+    "192.168.50.147",
+    "192.168.50.148",
+    "192.168.50.149",
+    "192.168.50.150",
+    "192.168.50.151",
+    "192.168.50.152",
+    "192.168.50.153",
+    "192.168.50.154",
+    "192.168.50.155",
+    "192.168.50.156",
+    "192.168.50.157",
+    "192.168.50.158",
+    "192.168.50.159",
+    "192.168.50.160",
+    "192.168.50.161",
+    "192.168.50.162",
+    "192.168.50.163",
+    "192.168.50.164",
+    "192.168.50.165",
+    "192.168.50.166",
+    "192.168.50.167",
+    "192.168.50.168",
+    "192.168.50.169",
+    "192.168.50.170",
+    "192.168.50.171",
+    "192.168.50.172",
+    "192.168.50.173",
+    "192.168.50.174",
+    "192.168.50.175",
+    "192.168.50.176",
+    "192.168.50.177",
+    "192.168.50.178",
+    "192.168.50.179",
+    "192.168.50.180",
+    "192.168.50.181",
+    "192.168.50.182",
+    "192.168.50.183",
+    "192.168.50.184",
+    "192.168.50.185",
+    "192.168.50.186",
+    "192.168.50.187",
+    "192.168.50.188",
+    "192.168.50.189",
+    "192.168.50.190",
+    "192.168.50.191",
+    "192.168.50.192",
+    "192.168.50.193",
+    "192.168.50.194",
+    "192.168.50.195",
+    "192.168.50.196",
+    "192.168.50.197",
+    "192.168.50.198",
+    "192.168.50.199",
+    "192.168.50.200",
+    "192.168.50.201",
+    "192.168.50.202",
+    "192.168.50.203",
+    "192.168.50.204",
+    "192.168.50.205",
+    "192.168.50.206",
+    "192.168.50.207",
+    "192.168.50.208",
+    "192.168.50.209",
+    "192.168.50.210",
+    "192.168.50.211",
+    "192.168.50.212",
+    "192.168.50.213",
+    "192.168.50.214",
+    "192.168.50.215",
+    "192.168.50.216",
+    "192.168.50.217",
+    "192.168.50.218",
+    "192.168.50.219",
+    "192.168.50.220",
+    "192.168.50.221",
+    "192.168.50.222",
+    "192.168.50.223",
+    "192.168.50.224",
+    "192.168.50.225",
+    "192.168.50.226",
+    "192.168.50.227",
+    "192.168.50.228",
+    "192.168.50.229",
+    "192.168.50.230",
+    "192.168.50.231",
+    "192.168.50.232",
+    "192.168.50.233",
+    "192.168.50.234",
+    "192.168.50.235",
+    "192.168.50.236",
+    "192.168.50.237",
+    "192.168.50.238",
+    "192.168.50.239",
+    "192.168.50.240",
+    "192.168.50.241",
+    "192.168.50.242",
+    "192.168.50.243",
+    "192.168.50.244",
+    "192.168.50.245",
+    "192.168.50.246",
+    "192.168.50.247",
+    "192.168.50.248",
+    "192.168.50.249",
+    "192.168.50.250",
+    "192.168.50.251",
+    "192.168.50.252",
+    "192.168.50.253",
+    "192.168.50.254",
+    "192.168.50.255"
+  ]
+}

test/slash16_ips.json

@@ -0,0 +1 @@
+{"addresses":null}