feat: add masscan discovery backend (#403)

2026-02-28 20:51:47 +01:00
parent fd0d948c16
commit c37d584aa2
10 changed files with 359 additions and 6 deletions
@@ -0,0 +1,109 @@
+package masscan
+
+import (
+	"context"
+	"fmt"
+	"net/netip"
+	"strings"
+
+	"github.com/Ullaakut/cameradar/v6"
+	masscanlib "github.com/Ullaakut/masscan"
+)
+
+// Reporter reports scan progress and debug information.
+type Reporter interface {
+	Debug(step cameradar.Step, message string)
+	Progress(step cameradar.Step, message string)
+}
+
+// Runner is something that can run a masscan scan.
+type Runner interface {
+	Run(ctx context.Context) (*masscanlib.Run, error)
+}
+
+// Scanner scans targets and ports for RTSP streams.
+type Scanner struct {
+	runner   Runner
+	reporter Reporter
+}
+
+// New returns a Scanner configured with the provided targets and ports.
+func New(targets, ports []string, reporter Reporter) (*Scanner, error) {
+	runner, err := masscanlib.NewScanner(
+		masscanlib.WithTargets(targets...),
+		masscanlib.WithPorts(ports...),
+		masscanlib.WithOpenOnly(),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("creating masscan scanner: %w", err)
+	}
+
+	return &Scanner{
+		runner:   runner,
+		reporter: reporter,
+	}, nil
+}
+
+// Scan discovers RTSP streams on the configured targets and ports.
+func (s *Scanner) Scan(ctx context.Context) ([]cameradar.Stream, error) {
+	return runScan(ctx, s.runner, s.reporter)
+}
+
+func runScan(ctx context.Context, runner Runner, reporter Reporter) ([]cameradar.Stream, error) {
+	results, err := runner.Run(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("scanning network: %w", err)
+	}
+
+	for _, warning := range results.Warnings() {
+		reporter.Debug(cameradar.StepScan, "masscan warning: "+warning)
+	}
+
+	var streams []cameradar.Stream
+	for _, host := range results.Hosts {
+		address := strings.TrimSpace(host.Address)
+		if address == "" {
+			reporter.Progress(cameradar.StepScan, "Skipping host with empty address")
+			continue
+		}
+
+		addr, err := netip.ParseAddr(address)
+		if err != nil {
+			reporter.Progress(cameradar.StepScan, fmt.Sprintf("Skipping invalid address %q: %v", host.Address, err))
+			continue
+		}
+
+		for _, port := range host.Ports {
+			if port.Status != "open" {
+				continue
+			}
+
+			if port.Number <= 0 || port.Number > 65535 {
+				reporter.Progress(cameradar.StepScan, fmt.Sprintf("Skipping invalid port %d on %s", port.Number, host.Address))
+				continue
+			}
+
+			streams = append(streams, cameradar.Stream{
+				Address: addr,
+				Port:    uint16(port.Number),
+			})
+		}
+	}
+
+	reporter.Progress(cameradar.StepScan, fmt.Sprintf("Found %d RTSP streams", len(streams)))
+	updateSummary(reporter, streams)
+
+	return streams, nil
+}
+
+type summaryUpdater interface {
+	UpdateSummary(streams []cameradar.Stream)
+}
+
+func updateSummary(reporter Reporter, streams []cameradar.Stream) {
+	updater, ok := reporter.(summaryUpdater)
+	if !ok {
+		return
+	}
+	updater.UpdateSummary(streams)
+}
@@ -0,0 +1,133 @@
+package masscan
+
+import (
+	"context"
+	"errors"
+	"net/netip"
+	"sync"
+	"testing"
+
+	"github.com/Ullaakut/cameradar/v6"
+	masscanlib "github.com/Ullaakut/masscan"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRunScan(t *testing.T) {
+	tests := []struct {
+		name            string
+		result          *masscanlib.Run
+		err             error
+		wantStreams     []cameradar.Stream
+		wantDebug       []string
+		wantProgress    []string
+		wantErrContains string
+	}{
+		{
+			name: "filters invalid addresses, closed and invalid ports",
+			result: &masscanlib.Run{
+				Hosts: []masscanlib.Host{
+					{
+						Address: "192.0.2.10",
+						Ports: []masscanlib.Port{
+							{Number: 554, Status: "open"},
+							{Number: 8554, Status: "closed"},
+							{Number: 0, Status: "open"},
+						},
+					},
+					{Address: "not-an-ip", Ports: []masscanlib.Port{{Number: 8554, Status: "open"}}},
+					{Address: "", Ports: []masscanlib.Port{{Number: 8554, Status: "open"}}},
+				},
+			},
+			wantStreams: []cameradar.Stream{
+				{Address: netip.MustParseAddr("192.0.2.10"), Port: 554},
+			},
+			wantProgress: []string{
+				"Skipping invalid port 0 on 192.0.2.10",
+				"Skipping invalid address \"not-an-ip\": ParseAddr(\"not-an-ip\"): unable to parse IP",
+				"Skipping host with empty address",
+				"Found 1 RTSP streams",
+			},
+		},
+		{
+			name: "collects streams from multiple hosts",
+			result: &masscanlib.Run{
+				Hosts: []masscanlib.Host{
+					{Address: "192.0.2.10", Ports: []masscanlib.Port{{Number: 8554, Status: "open"}}},
+					{Address: "198.51.100.9", Ports: []masscanlib.Port{{Number: 554, Status: "open"}}},
+				},
+			},
+			wantStreams: []cameradar.Stream{
+				{Address: netip.MustParseAddr("192.0.2.10"), Port: 8554},
+				{Address: netip.MustParseAddr("198.51.100.9"), Port: 554},
+			},
+			wantProgress: []string{"Found 2 RTSP streams"},
+		},
+		{
+			name:            "returns error when scan fails",
+			err:             errors.New("scan failed"),
+			wantErrContains: "scanning network",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			reporter := &recordingReporter{}
+
+			streams, err := runScan(t.Context(), fakeRunner{result: test.result, err: test.err}, reporter)
+
+			if test.wantErrContains != "" {
+				require.Error(t, err)
+				assert.ErrorContains(t, err, test.wantErrContains)
+				assert.Empty(t, streams)
+				assert.Empty(t, reporter.progress)
+				assert.Equal(t, test.wantDebug, reporter.debug)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.Equal(t, test.wantStreams, streams)
+			assert.Equal(t, test.wantDebug, reporter.debug)
+			for _, progress := range test.wantProgress {
+				assert.Contains(t, reporter.progress, progress)
+			}
+		})
+	}
+}
+
+type fakeRunner struct {
+	result *masscanlib.Run
+	err    error
+}
+
+func (f fakeRunner) Run(context.Context) (*masscanlib.Run, error) {
+	return f.result, f.err
+}
+
+type recordingReporter struct {
+	mu       sync.Mutex
+	debug    []string
+	progress []string
+}
+
+func (r *recordingReporter) Start(cameradar.Step, string) {}
+
+func (r *recordingReporter) Done(cameradar.Step, string) {}
+
+func (r *recordingReporter) Progress(_ cameradar.Step, message string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.progress = append(r.progress, message)
+}
+
+func (r *recordingReporter) Debug(_ cameradar.Step, message string) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.debug = append(r.debug, message)
+}
+
+func (r *recordingReporter) Error(cameradar.Step, error) {}
+
+func (r *recordingReporter) Summary([]cameradar.Stream, error) {}
+
+func (r *recordingReporter) Close() {}