Adds option to make timing configurable

Author: robgonnella

README.md

@@ -1,5 +1,5 @@
 # go-lanscan
-![Coverage](https://img.shields.io/badge/Coverage-91.8%25-brightgreen)
+![Coverage](https://img.shields.io/badge/Coverage-91.4%25-brightgreen)
 
 A network cli and golang package that allows you to perform arp and syn
 scanning on a local area network.
@@ -62,6 +62,13 @@ sudo go-lanscan --no-progress --json
 
 # run only arp scanning (skip syn scanning)
 sudo go-lanscan --arp-only
+
+# set timing - this is how fast packets are sent to hosts
+# default is 100µs between packets
+# the faster you send packets (shorter the timing), the less accurate the results will be
+sudo go-lanscan --timing 1ms # set to 1 millisecond
+sudo go-lanscan --timing 500µs # set to 500 microseconds
+sudo go-lanscan --timing 500us # alternate symbol for microseconds
 ```
 
 ## Package Usage
@@ -84,6 +91,31 @@ First you must install the following dependencies
 
 You can provide the following options to all scanners
 
+- Provide specific timing duration
+
+This option is used to set a specific time to wait between sending packets
+to hosts. The default is 100µs. The shorter the timing, the faster packets
+will be sent, and the less accurate your results will be
+
+```go
+  timing := time.Microsecond * 200
+
+  fullScanner := scanner.NewFullScanner(
+		netInfo,
+		targets,
+		ports,
+		listenPort,
+		scanner.WithTiming(timing),
+  )
+
+  // or
+  fullScanner.SetTiming(timing)
+
+  // or
+  option := scanner.WithTiming(timing)
+  option(fullScanner)
+```
+
 - Provide channel for notifications when packet requests are sent to target
 
 ```go
@@ -100,11 +132,11 @@ You can provide the following options to all scanners
   )
 
   // or
-  option := scanner.WithRequestNotifications(requests)
-  option(requests)
+  synScanner.SetRequestNotifications(requests)
 
   // or
-  synScanner.SetRequestNotifications(requests)
+  option := scanner.WithRequestNotifications(requests)
+  option(synScanner)
 ```
 
 - Provide your own idle timeout. If no packets are received from our targets

internal/cli/root.go

@@ -9,6 +9,7 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/robgonnella/go-lanscan/internal/core"
+	"github.com/robgonnella/go-lanscan/internal/logger"
 	"github.com/robgonnella/go-lanscan/internal/util"
 	"github.com/robgonnella/go-lanscan/pkg/network"
 	"github.com/robgonnella/go-lanscan/pkg/oui"
@@ -23,6 +24,7 @@ func Root(
 	var printJson bool
 	var noProgress bool
 	var ports string
+	var timing string
 	var idleTimeoutSeconds int
 	var listenPort uint16
 	var ifaceName string
@@ -36,6 +38,8 @@ func Root(
 		Short: "Scan your LAN!",
 		Long:  `CLI to scan your Local Area Network`,
 		RunE: func(cmd *cobra.Command, args []string) error {
+			log := logger.New()
+
 			portList := strings.Split(ports, ",")
 
 			if ifaceName != userNet.Interface().Name {
@@ -74,6 +78,15 @@ func Root(
 				coreScanner.IncludeVendorInfo(vendorRepo)
 			}
 
+			timingDuration, err := time.ParseDuration(timing)
+
+			if err != nil {
+				log.Error().Err(err).Msg("invalid timing value")
+				return err
+			}
+
+			coreScanner.SetTiming(timingDuration)
+
 			portLen := util.PortTotal(portList)
 
 			targetLen := util.TotalTargets(targets)
@@ -96,6 +109,7 @@ func Root(
 		},
 	}
 
+	cmd.Flags().StringVar(&timing, "timing", "100µs", "set time between packet sends - the faster you send the less accurate the result will be")
 	cmd.Flags().BoolVar(&printJson, "json", false, "output json instead of table text")
 	cmd.Flags().BoolVar(&arpOnly, "arp-only", false, "only perform arp scanning (skip syn scanning)")
 	cmd.Flags().BoolVar(&noProgress, "no-progress", false, "disable all output except for final results")

internal/cli/root_test.go

@@ -18,6 +18,39 @@ func TestRootCommand(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
+	t.Run("returns error if invalid timing duration is supplied", func(st *testing.T) {
+		mockNetwork := mock_network.NewMockNetwork(ctrl)
+
+		mockRunner := mock_core.NewMockRunner(ctrl)
+
+		mockVendor := mock_oui.NewMockVendorRepo(ctrl)
+
+		mockMAC, _ := net.ParseMAC("00:00:00:00:00:00")
+
+		mockCidr := "172.17.1.1/32"
+
+		_, mockIPNet, _ := net.ParseCIDR(mockCidr)
+
+		mockNetwork.EXPECT().Interface().AnyTimes().Return(&net.Interface{
+			Name:         "test-interface",
+			HardwareAddr: mockMAC,
+		})
+
+		mockNetwork.EXPECT().Cidr().AnyTimes().Return(mockCidr)
+
+		mockNetwork.EXPECT().IPNet().AnyTimes().Return(mockIPNet)
+
+		cmd, err := cli.Root(mockRunner, mockNetwork, mockVendor)
+
+		assert.NoError(st, err)
+
+		cmd.SetArgs([]string{"--timing", "nope"})
+
+		err = cmd.Execute()
+
+		assert.Error(st, err)
+	})
+
 	t.Run("initializes and runs full scanner", func(st *testing.T) {
 		mockNetwork := mock_network.NewMockNetwork(ctrl)
 

mock/scanner/scanner.go

@@ -30,6 +30,7 @@ type ArpScanner struct {
 	requestNotifier  chan *Request
 	scanning         bool
 	lastPacketSentAt time.Time
+	timing           time.Duration
 	idleTimeout      time.Duration
 	vendorRepo       oui.VendorRepo
 	scanningMux      *sync.RWMutex
@@ -51,7 +52,8 @@ func NewArpScanner(
 		cap:              &defaultPacketCapture{},
 		networkInfo:      networkInfo,
 		resultChan:       make(chan *ScanResult),
-		idleTimeout:      time.Second * 5,
+		timing:           defaultTiming,
+		idleTimeout:      defaultIdleTimeout,
 		scanning:         false,
 		lastPacketSentAt: time.Time{},
 		scanningMux:      &sync.RWMutex{},
@@ -108,7 +110,7 @@ func (s *ArpScanner) Scan() error {
 
 	go s.readPackets()
 
-	limiter := time.NewTicker(defaultAccuracy)
+	limiter := time.NewTicker(s.timing)
 	defer limiter.Stop()
 
 	if len(s.targets) == 0 {
@@ -142,6 +144,10 @@ func (s *ArpScanner) Stop() {
 	}
 }
 
+func (s *ArpScanner) SetTiming(d time.Duration) {
+	s.timing = d
+}
+
 func (s *ArpScanner) SetRequestNotifications(c chan *Request) {
 	s.requestNotifier = c
 }

pkg/scanner/arpscan.go

@@ -148,6 +148,11 @@ func (s *FullScanner) Stop() {
 	s.debug.Info().Msg("all scanners stopped")
 }
 
+func (s *FullScanner) SetTiming(d time.Duration) {
+	s.arpScanner.SetTiming(d)
+	s.synScanner.SetTiming(d)
+}
+
 func (s *FullScanner) SetRequestNotifications(c chan *Request) {
 	s.arpScanner.SetRequestNotifications(c)
 	s.synScanner.SetRequestNotifications(c)

pkg/scanner/fullscan.go

@@ -11,7 +11,10 @@ import (
 // How long to wait before sending next packet
 // the faster you send packets the more packets
 // will be missed when reading
-const defaultAccuracy = time.Microsecond * 100
+const defaultTiming = time.Microsecond * 100
+
+// If no packets are received for this period of time, exit with timeout
+const defaultIdleTimeout = time.Second * 5
 
 type ScannerOption = func(s Scanner)
 
@@ -38,3 +41,9 @@ func WithPacketCapture(cap PacketCapture) ScannerOption {
 		s.SetPacketCapture(cap)
 	}
 }
+
+func WithTiming(duration time.Duration) ScannerOption {
+	return func(s Scanner) {
+		s.SetTiming(duration)
+	}
+}

pkg/scanner/options.go

@@ -30,6 +30,7 @@ func TestOptions(t *testing.T) {
 		scanner.NewArpScanner(
 			[]string{},
 			netInfo,
+			scanner.WithTiming(time.Millisecond),
 			scanner.WithIdleTimeout(time.Second*5),
 			scanner.WithPacketCapture(testPacketCapture),
 			scanner.WithRequestNotifications(requestNotifier),
@@ -41,6 +42,7 @@ func TestOptions(t *testing.T) {
 			[]string{},
 			[]string{},
 			54321,
+			scanner.WithTiming(time.Millisecond),
 			scanner.WithIdleTimeout(time.Second*5),
 			scanner.WithPacketCapture(testPacketCapture),
 			scanner.WithRequestNotifications(requestNotifier),
@@ -52,6 +54,7 @@ func TestOptions(t *testing.T) {
 			netInfo,
 			[]string{},
 			54321,
+			scanner.WithTiming(time.Millisecond),
 			scanner.WithIdleTimeout(time.Second*5),
 			scanner.WithPacketCapture(testPacketCapture),
 			scanner.WithRequestNotifications(requestNotifier),

pkg/scanner/options_test.go

@@ -37,6 +37,7 @@ type SynScanner struct {
 	requestNotifier  chan *Request
 	scanning         bool
 	lastPacketSentAt time.Time
+	timing           time.Duration
 	idleTimeout      time.Duration
 	scanningMux      *sync.RWMutex
 	packetSentAtMux  *sync.RWMutex
@@ -62,7 +63,8 @@ func NewSynScanner(
 		ports:            ports,
 		listenPort:       listenPort,
 		resultChan:       make(chan *ScanResult),
-		idleTimeout:      time.Second * 5,
+		timing:           defaultTiming,
+		idleTimeout:      defaultIdleTimeout,
 		scanning:         false,
 		lastPacketSentAt: time.Time{},
 		scanningMux:      &sync.RWMutex{},
@@ -135,7 +137,7 @@ func (s *SynScanner) Scan() error {
 
 	go s.readPackets()
 
-	limiter := time.NewTicker(defaultAccuracy)
+	limiter := time.NewTicker(s.timing)
 	defer limiter.Stop()
 
 	for _, target := range s.targets {
@@ -170,6 +172,10 @@ func (s *SynScanner) Stop() {
 	}
 }
 
+func (s *SynScanner) SetTiming(d time.Duration) {
+	s.timing = d
+}
+
 func (s *SynScanner) SetRequestNotifications(c chan *Request) {
 	s.requestNotifier = c
 }

pkg/scanner/synscan.go

@@ -30,6 +30,7 @@ type Scanner interface {
 	Scan() error
 	Stop()
 	Results() chan *ScanResult
+	SetTiming(d time.Duration)
 	SetRequestNotifications(c chan *Request)
 	SetIdleTimeout(d time.Duration)
 	IncludeVendorInfo(repo oui.VendorRepo)