scout

package module
v0.4.16 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 30, 2026 License: MIT Imports: 30 Imported by: 0

README

Scout

Point it at your app. See every way in.

CI Go Reference Go Report Card Release

Scout is a self-hosted, open-source vulnerability scanner and attack-surface mapper for developers. Point it at a running app, a website, or a repo. It probes for weaknesses, merges them into one findings model, scores the result into a letter grade, and tells you the exact fix for each issue — ranked by how much safety each fix buys per hour of work.

It is the third tool in a family with Sentinel (runtime defense) and Pulse (observability), and shares their ergonomics: one Mount(), an embedded dashboard, and zero external services.

⚠️ Project status: pre-release (v0.x)

The engine, scoring, dashboard, CLI, scheduling, alerts, reports, integrations and optional AI are complete and tested. As of v0.3.0, Scout ships nine collectors (35 checks) — headers, TLS, DNS/email, exposure, config, a GET-only crawler (pages/forms/CSRF/endpoints), a port scan for exposed services, repo secret scanning, and Dockerfile linting — and finds real, verified issues.

Still to come: active DAST input testing (SQLi/XSS/SSRF), auth/access control (JWT, IDOR, CORS), Nuclei, dependency-CVE/SAST/container scanning, and a host agent. Until those land Scout covers the HTTP surface, exposed services and source analysis — not the full OWASP Top 10 — so it is v0.x, not v1.0. Adding collectors is straightforward: see Add your own checks.


Contents


Install

CLI:

go install github.com/MUKE-coder/scout/cmd/scout@latest
scout version

No CGo, no Node — the dashboard is baked into the binary. Builds on Linux, macOS and Windows.

As a library (to mount the dashboard in a Gin app):

go get github.com/MUKE-coder/scout

Concepts in 60 seconds

  • Target — what you scan: a URL (--target), a repo (--repo), or both. Each target has an environment (dev / staging / prod).
  • Mode — how aggressive a scan is: passive (read only) → safe (harmless probes) → active (real payloads) → intrusive (brute force, state-changing). Every check declares its mode.
  • Environment caps the mode. prod runs at most safe unless you opt in per target; it never runs intrusive. This is enforced, not advisory.
  • Finding — one issue, with severity, confidence, asset, evidence, a stack-specific fix, and a stable fingerprint so Scout tracks it across scans (new / fixed / regressed).
  • Grade — a 0–100 score and an A–F letter, modeled on SSL Labs: one serious flaw caps the grade. Fixes are ranked by points regained per hour.

Use cases

1. Scan a public website (black-box)

Nothing is installed on the target. Scout crawls and inspects it from the outside.

# Safe, read-only scan (the default).
scout scan --target https://example.com

# Preview what an active scan would do — and send nothing.
scout scan --target https://example.com --mode active --env prod --dry-run

# Machine-readable output.
scout scan --target https://example.com --json  > result.json
scout scan --target https://example.com --sarif result.sarif

An active scan of a site you own needs proof of ownership first:

scout ownership --target https://example.com
# publish the printed token as a DNS TXT record or at
# /.well-known/scout-verify.txt, then:
scout scan --target https://example.com --mode active --allow-active

Scans are saved to scout.db by default, so you can diff and report on them later. Use --db "" to keep nothing.

2. Add the dashboard to a Gin app (white-box)

One line mounts Scout inside your app and hands the scanner your real route table — so it can flag unprotected routes before sending any traffic.

package main

import (
    "github.com/gin-gonic/gin"
    scout "github.com/MUKE-coder/scout"
)

func main() {
    r := gin.Default()
    // ... your routes ...
    scout.Mount(r, scout.Config{AppName: "My API"})
    r.Run(":8080")
}

Now /scout/ui/ is the dashboard, /scout/api/ the REST API, and /scout/ws/live the live scan feed. In dev the default login is admin / scout; outside dev those defaults are refused (set SCOUT_USERNAME / SCOUT_PASSWORD). Full example: examples/gin-mount.

Route-table checks. Called after your routes are defined, Mount introspects the Gin engine for its method/path table. To also flag unprotected routes before any request is sent, hand Scout a table that includes each route's auth middleware — your framework usually knows this better than Gin's introspection can:

scout.Mount(r, cfg, scout.WithRoutes(
    core.Route{Method: "GET", Path: "/admin", Middleware: []string{"Logger"}},      // flagged: no auth
    core.Route{Method: "GET", Path: "/account", Middleware: []string{"JWTAuth"}},   // ok
))

The resolved table is attached to your configured targets and served at /scout/api/routes.

3. Gate a CI pipeline

Fail a build when a scan turns up new high/critical issues, and upload results to GitHub's Security tab.

scout ci --repo . --fail-on high --new-only --sarif scout.sarif
  • Exit 0 = passed, 1 = gate failed, 2 = error.
  • --new-only counts only findings new or regressed since the target's previous scan (with no history, every finding counts — it fails safe).

A ready-to-copy workflow is in examples/ci/scout-ci.yml.

4. Continuously monitor production

Run the server; it hosts the dashboard and runs scheduled scans and alerts.

scout serve --addr :9090 --db scout.db

In scout.yaml:

environment: prod
targets:
  - name: shop
    url: https://shop.example.com

schedules:
  - name: nightly
    cron: "0 3 * * *"      # 3am; mode is capped by the environment (safe in prod)
    targets: [shop]

alerts:
  min_severity: high       # alert only on new/regressed high+ findings
  slack: { webhook_url: "https://hooks.slack.com/services/..." }

Scout alerts to Slack, Discord, email and HMAC-signed webhooks, only on findings that are new or regressed since the last scan. The dashboard's kill switch stops all scanning instantly.

5. Track what changed between scans
scout diff 3f2a9c 9b1c04        # by scan ID or unique prefix, oldest → newest

Shows new, regressed, fixed and unchanged findings. The same view is on the dashboard's History page. A finding that disappeared and came back counts as regressed, not new.

Mute noise with a reason and an expiry — accepted risks reopen automatically when they expire (done from the dashboard's finding panel).

6. Produce a report for a client or audit
scout report --out report.html      # open in a browser and print to PDF

A self-contained HTML report: grade, category scores, top fixes, and every open finding with its stack-specific remediation. Text from scanned sites is escaped, and the API serves it with scripts disabled. Also available from the dashboard's Settings → Reports (download or print-to-PDF), alongside JSON and CSV export and an OWASP Top 10 / ASVS compliance view.

7. Wire into Pulse and Sentinel

Optional and auto-detected — Scout is fully useful with neither.

integrations:
  pulse:    { url: http://localhost:7070 }   # scans appear as bands on Pulse charts
  sentinel: { url: http://localhost:6060 }   # Scout's exposure score feeds Sentinel

Tokens come from SCOUT_PULSE_TOKEN / SCOUT_SENTINEL_TOKEN. Scout probes each sibling's health endpoint and stays idle if it is not present.

8. Explain findings with AI (optional)

Off unless you enable it and provide a key. Scout talks to the Vercel AI Gateway (any provider/model).

ai:
  enabled: true
  model: anthropic/claude-sonnet-5.5
export AI_GATEWAY_API_KEY=vck_...

Then the finding panel gains Explain with AI, and Settings gains an AI stakeholder summary. Findings are redacted before anything leaves the process — evidence bodies are never sent; hosts, IPs, emails and tokens are masked — and the dashboard shows exactly what was sent.


Safety model

Scanning is safe by construction, not by good intentions:

  • Mode caps per environment — enforced; prod never runs intrusive.
  • Ownership verification — active scans of a remote host require a DNS TXT record or /.well-known/scout-verify.txt.
  • One guarded HTTP client — every request a check makes passes through kill switch → scan window → scope allowlist → per-host rate limit, and is signed with X-Scout-Scan so a WAF can recognize it.
  • Dry-run — --dry-run prints exactly what would run and sends nothing.

Details: docs/safety.md. Only scan systems you own or are authorized to test.


Configuration

Layered: defaults → scout.yaml → SCOUT_* env vars → flags (a flag wins only when passed). Unknown keys are rejected, so a typo can't silently disable a setting. Secrets (signing key, JWT secret, dashboard password, alert and integration tokens, AI key) come from the environment, never the file.

Every option is documented in scout.example.yaml; see docs/configuration.md for the precedence rules and the full SCOUT_* list.


The dashboard

Embedded React 19 app (Vercel/Linear aesthetic, dark and light), served at /scout/ui/:

  • Overview — grade ring, 30-day trend, category subscores, Fix-next, per-environment cards.
  • Findings — filter by severity, category, status and change; bulk accept, mute or reopen; a slide-over with evidence, the stack-specific fix, and a one-click Verify fix that re-runs just that check.
  • Live scan — per-collector progress over WebSocket, plus the kill switch.
  • History — compare any two scans.
  • Attack surface — an interactive domain → host → service → route map, colored by worst severity.
  • Compliance — OWASP Top 10 heatmap and ASVS coverage.
  • Settings — the effective config, exports, reports and the danger zone.

JWT auth with login rate limiting; default credentials refused outside dev.


Add your own checks

This is the one thing Scout needs to start finding issues, and the extension point is stable. A check implements core.Check, registers itself in init(), makes requests through the guarded client, and attaches a deterministic remediation — everything else (scoring, dedupe, history, the dashboard, SARIF, compliance) then works automatically.

See docs/collectors.md for the full contract and a complete, compiling example. Contributions of collectors are the most valuable thing you can send.


Development

go build ./...
go test ./...

Before pushing, run what CI runs (gofmt -l ., go vet ./..., go test -race ./..., gosec -exclude-dir=ui ./...). CI builds with CGO_ENABLED=0 on Linux, macOS and Windows. The dashboard build output ui/dist/ is committed; rebuild it with cd ui/dashboard && npm ci && npm run build. See CONTRIBUTING.md.


Documentation


License

MIT

Documentation

Overview

Package scout is a self-hosted vulnerability scanner and attack-surface mapper. Point it at your app. See every way in.

The simplest integration is one line in a Gin app:

scout.Mount(router, scout.Config{AppName: "My API"})

Index

Constants

View Source
const (
	DefaultRateLimit    = 10
	DefaultConcurrency  = 4
	DefaultCheckTimeout = 60 * time.Second
	DefaultRetention    = 90 * 24 * time.Hour
	DefaultUsername     = "admin"
	DefaultPassword     = "scout"
)

Defaults for a fresh Config.

View Source
const (
	BasePath = "/scout"
	APIPath  = BasePath + "/api"
	UIPath   = BasePath + "/ui"
	WSPath   = BasePath + "/ws/live"
)

URL namespace shared with Sentinel and Pulse.

View Source
const DefaultConfigFile = "scout.yaml"

DefaultConfigFile is looked for in the working directory when no --config path is given.

View Source
const DefaultPruneInterval = time.Hour

DefaultPruneInterval is how often the background pruner runs.

Variables

View Source
var ErrShutdownTimeout = errors.New("scout: shutdown timed out waiting for goroutines")

ErrShutdownTimeout is returned when goroutines outlive the shutdown deadline.

View Source
var Version = resolveVersion()

Version is the Scout version, resolved once at startup. Resolution order:

  1. the release ldflags stamp (buildVersion), when present;
  2. the module version recorded in the binary by `go install module@vX`;
  3. a dev marker for a local checkout build.

Functions

func FindConfig

func FindConfig(explicit string) string

FindConfig returns explicit if set, else DefaultConfigFile when it exists in the working directory, else "".

func NewLogger

func NewLogger(w io.Writer, level, format string) (*slog.Logger, error)

NewLogger returns a structured logger. level is debug|info|warn|error and format is text|json.

func Prune

func Prune(ctx context.Context, store storage.Store, retention time.Duration, now time.Time) (int, error)

Prune deletes scans that finished more than retention ago and returns how many were removed.

Types

type AIConfig

type AIConfig struct {
	Enabled bool `json:"enabled" yaml:"enabled"`
	// Model is any AI Gateway model ID, e.g. "anthropic/claude-sonnet-5.5".
	Model string `json:"model,omitempty" yaml:"model"`
	// BaseURL overrides the Gateway endpoint (OpenAI-compatible).
	BaseURL string `json:"base_url,omitempty" yaml:"base_url"`
}

AIConfig enables optional AI explanations through the Vercel AI Gateway. The API key is read only from the AI_GATEWAY_API_KEY environment variable so it never lands in scout.yaml.

func (*AIConfig) Validate

func (a *AIConfig) Validate() error

Validate checks the AI settings.

type AlertsConfig

type AlertsConfig struct {
	// MinSeverity is the lowest severity that alerts (default high).
	MinSeverity string `json:"min_severity,omitempty" yaml:"min_severity"`
	// DashboardURL is linked from every alert.
	DashboardURL string           `json:"dashboard_url,omitempty" yaml:"dashboard_url"`
	Slack        *alerts.Slack    `json:"-" yaml:"slack"`
	Discord      *alerts.Discord  `json:"-" yaml:"discord"`
	Email        *alerts.Email    `json:"-" yaml:"email"`
	Webhooks     []alerts.Webhook `json:"-" yaml:"webhooks"`
}

AlertsConfig configures notifications for new or regressed findings.

func (*AlertsConfig) Validate

func (a *AlertsConfig) Validate() error

Validate checks every configured channel.

type Config

type Config struct {
	AppName     string           `json:"app_name" yaml:"app_name"`
	Environment core.Environment `json:"environment" yaml:"environment"`
	// Mode is the requested mode. It is always capped by the environment.
	Mode    core.Mode     `json:"mode" yaml:"mode"`
	Targets []core.Target `json:"targets,omitempty" yaml:"targets"`
	// Routes is the app's route table, handed to the scanner by scout.Mount
	// (via gin introspection or WithRoutes). It is attached to configured
	// targets that have none, so the route-table checks (unprotected routes)
	// run with no attack traffic. Set programmatically, not from YAML.
	Routes []core.Route `json:"-" yaml:"-"`
	// Identities are disposable test accounts for access-control checks such
	// as IDOR. They are attached to configured targets that declare none.
	// Never real users; carried into scans but never written to results.
	Identities []core.Identity `json:"-" yaml:"identities"`
	// Repo is a local source path for the code and supply-chain collectors,
	// attached to configured targets that declare none (set via WithRepo, e.g.
	// by a mounted app that knows its own project root). It is honoured only in
	// the dev environment — a dashboard reachable in staging/prod must not serve
	// source fragments — and ignored with a log line elsewhere.
	Repo  string `json:"-" yaml:"repo"`
	Scope Scope  `json:"scope" yaml:"scope"`
	// Criticality weights findings by asset (payments API 1.5, marketing
	// site 0.7). First matching rule wins.
	Criticality []scoring.CriticalityRule `json:"criticality,omitempty" yaml:"criticality"`

	// RateLimit is the max outbound requests per second per target.
	RateLimit int `json:"rate_limit" yaml:"rate_limit"`
	// Concurrency is the number of checks run in parallel.
	Concurrency int `json:"concurrency" yaml:"concurrency"`
	// CheckTimeout bounds a single check run.
	CheckTimeout time.Duration `json:"check_timeout" yaml:"check_timeout"`

	// DBPath is the SQLite file. Empty uses in-memory storage only.
	DBPath string `json:"db_path" yaml:"db"`
	// Retention is how long scan history is kept.
	Retention time.Duration `json:"retention" yaml:"retention"`

	// Window restricts when scans may run; nil allows any time.
	Window *ScanWindow `json:"window,omitempty" yaml:"window"`
	// Schedules run scans automatically while Scout is serving.
	Schedules []Schedule `json:"schedules,omitempty" yaml:"schedules"`
	// Alerts notify about new or regressed findings after each saved scan.
	Alerts *AlertsConfig `json:"alerts,omitempty" yaml:"alerts"`
	// AI enables optional, redacted AI explanations (off by default).
	AI *AIConfig `json:"ai,omitempty" yaml:"ai"`
	// Integrations links optional Pulse and Sentinel instances.
	Integrations *IntegrationsConfig `json:"integrations,omitempty" yaml:"integrations"`

	// SigningKey signs the X-Scout-Scan self-test header. Generated if empty.
	SigningKey string `json:"-" yaml:"signing_key"`

	// Dashboard credentials. Defaults are refused outside dev.
	Username  string `json:"-" yaml:"username"`
	Password  string `json:"-" yaml:"password"`
	JWTSecret string `json:"-" yaml:"jwt_secret"`
}

Config is the full Scout configuration. Build it directly or with options.

func DefaultConfig

func DefaultConfig() Config

DefaultConfig returns a dev-safe config: dev environment, Safe mode.

func LoadConfig

func LoadConfig(path string, getenv func(string) string) (Config, error)

LoadConfig builds a Config from defaults, then the YAML file at path (if path is non-empty), then SCOUT_* environment variables read with getenv. Callers apply command-line flags last. The file is decoded strictly: an unknown key is an error, so a typo cannot silently disable a setting.

func NewConfig

func NewConfig(opts ...Option) (Config, error)

NewConfig builds a config from defaults plus options, then validates it.

func (Config) EffectiveMode

func (c Config) EffectiveMode() core.Mode

EffectiveMode is the requested mode capped by the environment.

func (Config) UsesDefaultCredentials

func (c Config) UsesDefaultCredentials() bool

UsesDefaultCredentials reports whether the dashboard login is unchanged.

func (Config) Validate

func (c Config) Validate() error

Validate rejects unsafe or inconsistent configuration.

func (Config) ValidateDashboard

func (c Config) ValidateDashboard() error

ValidateDashboard adds the checks needed before serving the dashboard: default credentials are refused outside dev.

type IntegrationsConfig

type IntegrationsConfig struct {
	Pulse    *SiblingConfig `json:"pulse,omitempty" yaml:"pulse"`
	Sentinel *SiblingConfig `json:"sentinel,omitempty" yaml:"sentinel"`
}

IntegrationsConfig configures the optional Pulse and Sentinel links.

func (*IntegrationsConfig) Validate

func (c *IntegrationsConfig) Validate() error

Validate checks the integration URLs.

type Lifecycle

type Lifecycle struct {
	// contains filtered or unexported fields
}

Lifecycle owns Scout's background goroutines. Every goroutine is started through Go and receives a context that is cancelled on Shutdown, which then waits for all of them to return.

func NewLifecycle

func NewLifecycle(parent context.Context) *Lifecycle

NewLifecycle returns a lifecycle derived from parent.

func (*Lifecycle) Context

func (l *Lifecycle) Context() context.Context

Context is cancelled when shutdown begins.

func (*Lifecycle) Go

func (l *Lifecycle) Go(fn func(ctx context.Context))

Go runs fn in a tracked goroutine.

func (*Lifecycle) Shutdown

func (l *Lifecycle) Shutdown(timeout time.Duration) error

Shutdown cancels the context and waits up to timeout for goroutines to return. It is safe to call more than once.

type Option

type Option func(*Config)

Option mutates a Config.

func WithConfig

func WithConfig(c Config) Option

WithConfig replaces the whole config; later options still apply on top.

func WithDB

func WithDB(path string) Option

WithDB sets the SQLite file path.

func WithEnvironment

func WithEnvironment(e core.Environment) Option

WithEnvironment sets the environment, which caps the mode.

func WithMode

func WithMode(m core.Mode) Option

WithMode sets the requested scan mode.

func WithRepo added in v0.4.10

func WithRepo(path string) Option

WithRepo attaches a local source path for the code and supply-chain collectors (code.secrets, code.vulnerable-deps, SAST, …) to configured targets that declare no repo. Use it from a mounted app that knows its own project root, so the dashboard shows source findings for the same target as the live checks, in one scan series:

scout.Mount(r, cfg, scout.WithTarget(cfg.AppURL), scout.WithRepo(projectRoot))

For safety it is honoured only when the environment is dev — findings quote source lines, so a dashboard reachable in staging/prod must not read the tree — and is ignored with a log line otherwise. The CLI's --repo is unaffected.

func WithRoutes added in v0.3.1

func WithRoutes(routes ...core.Route) Option

WithRoutes hands Scout the app's route table. Prefer this when your framework knows each route's authorization middleware (roles, permissions): it is strictly richer than what gin introspection can recover, and the "route has no auth middleware" check depends on the Middleware field.

scout.Mount(r, cfg, scout.WithRoutes(myRouteTable...))

func WithScope

func WithScope(s Scope) Option

WithScope sets the scope allowlist.

func WithTarget

func WithTarget(url string) Option

WithTarget adds a target URL in the current environment.

func WithTestIdentities added in v0.3.1

func WithTestIdentities(ids ...core.Identity) Option

WithTestIdentities registers disposable test accounts for the access-control checks (IDOR and future identity-dependent probes). Each identity carries the headers that authenticate it and the private resources it owns; the checks are read-only and never use real user credentials.

scout.WithTestIdentities(
	core.Identity{Name: "alice", Headers: map[string]string{"Cookie": "session=a"}, Owns: []string{"/api/users/1"}},
	core.Identity{Name: "bob", Headers: map[string]string{"Cookie": "session=b"}, Owns: []string{"/api/users/2"}},
)

type ScanWindow

type ScanWindow struct {
	Start    string   `json:"start" yaml:"start"` // "HH:MM"
	End      string   `json:"end" yaml:"end"`     // "HH:MM"; before Start wraps past midnight
	Days     []string `json:"days,omitempty" yaml:"days"`
	Timezone string   `json:"timezone,omitempty" yaml:"timezone"` // IANA name; empty is local time
}

ScanWindow is the config-file form of a daily scan window.

func (*ScanWindow) EngineWindow

func (w *ScanWindow) EngineWindow() (*engine.Window, error)

EngineWindow converts the window for the engine. A nil window is nil.

type Schedule

type Schedule struct {
	Name string `json:"name" yaml:"name"`
	// Cron is a standard 5-field expression ("0 3 * * *") or a descriptor
	// such as "@daily".
	Cron string `json:"cron" yaml:"cron"`
	// Timezone is an IANA name; empty means local time.
	Timezone string `json:"timezone,omitempty" yaml:"timezone"`
	// Targets are target names; empty means every configured target.
	Targets []string `json:"targets,omitempty" yaml:"targets"`
	// Mode caps this schedule (default safe). The environment caps it further.
	Mode string `json:"mode,omitempty" yaml:"mode"`
}

Schedule runs scans on a cron schedule.

type ScheduleInfo

type ScheduleInfo struct {
	Schedule
	Next time.Time `json:"next"`
}

ScheduleInfo is a schedule with its next run, for the dashboard.

type Scope

type Scope = core.Scope

Scope limits what a scan may touch. Empty Hosts means "only the target's own host"; Scout never widens scope implicitly.

type Scout

type Scout struct {
	// contains filtered or unexported fields
}

Scout is a mounted Scout instance.

func Mount

func Mount(r gin.IRouter, cfg Config, opts ...Option) *Scout

Mount attaches Scout to a Gin router under /scout and returns the instance. It is the one-line integration:

scout.Mount(router, scout.Config{AppName: "My API"})

Mount panics on invalid configuration, matching Sentinel and Pulse; use New + Register when you want the error instead.

func New

func New(cfg Config, opts ...Option) (*Scout, error)

New builds a Scout instance without mounting it.

func (*Scout) Close

func (s *Scout) Close(timeout time.Duration) error

Close stops background work and closes storage.

func (*Scout) Config

func (s *Scout) Config() Config

Config returns the effective configuration.

func (*Scout) Register

func (s *Scout) Register(r gin.IRouter)

Register adds the /scout route group to r.

func (*Scout) Routes added in v0.3.1

func (s *Scout) Routes() []core.Route

Routes returns the resolved app route table (populated by Register).

func (*Scout) Store

func (s *Scout) Store() storage.Store

Store returns the backing store.

type SiblingConfig

type SiblingConfig struct {
	URL  string `json:"url,omitempty" yaml:"url"`
	Path string `json:"path,omitempty" yaml:"path"`
}

SiblingConfig points Scout at a Pulse or Sentinel instance. Tokens come from the environment (SCOUT_PULSE_TOKEN, SCOUT_SENTINEL_TOKEN), not the file.

Directories

Path Synopsis
Package ai adds optional AI explanations through the Vercel AI Gateway's OpenAI-compatible API.
Package ai adds optional AI explanations through the Vercel AI Gateway's OpenAI-compatible API.
Package alerts notifies Slack, Discord, email and webhooks when a scan finds new or regressed findings at or above a severity threshold.
Package alerts notifies Slack, Discord, email and webhooks when a scan finds new or regressed findings at or above a severity threshold.
Package api serves the Scout REST API under /scout/api/ and the live WebSocket at /scout/ws/live.
Package api serves the Scout REST API under /scout/api/ and the live WebSocket at /scout/ws/live.
Package cli implements the scout command-line interface.
Package cli implements the scout command-line interface.
cmd
scout command
Command scout is the Scout CLI.
Command scout is the Scout CLI.
Package collectors holds Scout's check collectors (external, headers, exposure, ports, DNS, nuclei, DAST, host, code).
Package collectors holds Scout's check collectors (external, headers, exposure, ports, DNS, nuclei, DAST, host, code).
all
Package all blank-imports every built-in collector so their init() functions register their checks into core.DefaultRegistry.
Package all blank-imports every built-in collector so their init() functions register their checks into core.DefaultRegistry.
authz
Package authz holds the authentication and access-control checks.
Package authz holds the authentication and access-control checks.
clientlib
Package clientlib finds known-vulnerable client-side libraries loaded by a live page.
Package clientlib finds known-vulnerable client-side libraries loaded by a live page.
clientside
Package clientside flags client-side integrity problems in a page's HTML: cross-origin scripts and stylesheets loaded without Subresource Integrity, and mixed content (an HTTPS page pulling resources over plain HTTP).
Package clientside flags client-side integrity problems in a page's HTML: cross-origin scripts and stylesheets loaded without Subresource Integrity, and mixed content (an HTTPS page pulling resources over plain HTTP).
codeaudit
Package codeaudit is a light static analyzer (SAST-lite) over a target's source tree (Target.Repo).
Package codeaudit is a light static analyzer (SAST-lite) over a target's source tree (Target.Repo).
config
Package config checks configuration posture: framework debug mode left on, shipped default credentials, and misconfigured sibling tools (Sentinel, Pulse) such as monitor-only WAF or in-memory storage in production.
Package config checks configuration posture: framework debug mode left on, shipped default credentials, and misconfigured sibling tools (Sentinel, Pulse) such as monitor-only WAF or in-memory storage in production.
crawl
Package crawl spiders a target from its base URL to discover pages, forms and API endpoints, and flags state-changing forms that carry no CSRF token.
Package crawl spiders a target from its base URL to discover pages, forms and API endpoints, and flags state-changing forms that carry no CSRF token.
dast
Package dast holds the active application-testing checks (injection and related classes).
Package dast holds the active application-testing checks (injection and related classes).
dns
Package dns checks a target domain's DNS posture: email anti-spoofing records (SPF, DKIM, DMARC), certificate-issuance control (CAA), and dangling / takeover-prone CNAMEs.
Package dns checks a target domain's DNS posture: email anti-spoofing records (SPF, DKIM, DMARC), certificate-issuance control (CAA), and dangling / takeover-prone CNAMEs.
dockerfile
Package dockerfile lints Dockerfiles in a target's source tree for common security misconfigurations: running as root, unpinned base images, remote ADD, and secrets baked into ENV/ARG.
Package dockerfile lints Dockerfiles in a target's source tree for common security misconfigurations: running as root, unpinned base images, remote ADD, and secrets baked into ENV/ARG.
exposure
Package exposure checks for sensitive files and endpoints that should never be reachable: dotfiles, VCS metadata, API docs, metrics, backups, directory listings and admin dashboards.
Package exposure checks for sensitive files and endpoints that should never be reachable: dotfiles, VCS metadata, API docs, metrics, backups, directory listings and admin dashboards.
fingerprint
Package fingerprint flags information that helps an attacker fingerprint the stack: software/version banners in response headers, and directory listings (autoindex) that enumerate files.
Package fingerprint flags information that helps an attacker fingerprint the stack: software/version banners in response headers, and directory listings (autoindex) that enumerate files.
framework
Package framework runs framework-specific exposure checks, gated by the stack Scout detects on the target.
Package framework runs framework-specific exposure checks, gated by the stack Scout detects on the target.
headers
Package headers checks HTTP security-hardening headers.
Package headers checks HTTP security-hardening headers.
infodisc
Package infodisc flags information disclosure: verbose error pages / stack traces that leak internals, and GraphQL schema introspection left enabled.
Package infodisc flags information disclosure: verbose error pages / stack traces that leak internals, and GraphQL schema introspection left enabled.
internal/httpx
Package httpx is the shared HTTP helper for collectors.
Package httpx is the shared HTTP helper for collectors.
internal/repo
Package repo is a shared helper for collectors that read a target's source tree (Target.Repo).
Package repo is a shared helper for collectors that read a target's source tree (Target.Repo).
netsweep
Package netsweep scans a whole network range (CIDR) for reachable risky services, host by host.
Package netsweep scans a whole network range (CIDR) for reachable risky services, host by host.
phpruntime
Package phpruntime flags a target running an outdated PHP runtime that is vulnerable to the "php2shell" flaws — CVE-2026-109618 and CVE-2026-109619, two critical (CVSS 9.2) unauthenticated remote-code-execution bugs in PHP core, fixed on 2026-10-21 in PHP 8.2.35 / 8.3.36 / 8.4.27 / 8.5.12.
Package phpruntime flags a target running an outdated PHP runtime that is vulnerable to the "php2shell" flaws — CVE-2026-109618 and CVE-2026-109619, two critical (CVSS 9.2) unauthenticated remote-code-execution bugs in PHP core, fixed on 2026-10-21 in PHP 8.2.35 / 8.3.36 / 8.4.27 / 8.5.12.
ports
Package ports detects risky back-end services that are reachable on the target's own host — exposed databases, caches, container APIs and remote shells that are usually meant to stay private.
Package ports detects risky back-end services that are reachable on the target's own host — exposed databases, caches, container APIs and remote shells that are usually meant to stay private.
sca
Package sca performs Software Composition Analysis: it inventories a repo's dependencies across every major ecosystem (from lockfiles/manifests) and matches them against known vulnerabilities via the intel layer (OSV.dev, which aggregates NVD, GitHub Advisories, RustSec, PyPA, the Go vuln DB …).
Package sca performs Software Composition Analysis: it inventories a repo's dependencies across every major ecosystem (from lockfiles/manifests) and matches them against known vulnerabilities via the intel layer (OSV.dev, which aggregates NVD, GitHub Advisories, RustSec, PyPA, the Go vuln DB …).
secrets
Package secrets scans a target's source tree (Target.Repo) for credentials that should never be committed: cloud keys, private keys, tokens and obvious password/secret assignments.
Package secrets scans a target's source tree (Target.Repo) for credentials that should never be committed: cloud keys, private keys, tokens and obvious password/secret assignments.
templates
Package templates runs declarative YAML detection templates against a live target — a safe, Nuclei-compatible subset.
Package templates runs declarative YAML detection templates against a live target — a safe, Nuclei-compatible subset.
tls
Package tls checks a target's TLS configuration: protocol versions, cipher strength, certificate validity and expiry, chain, and HSTS preload eligibility.
Package tls checks a target's TLS configuration: protocol versions, cipher strength, certificate validity and expiry, chain, and HSTS preload eligibility.
vulncheck
Package vulncheck finds known, reachable vulnerabilities in a Go module's dependencies by running govulncheck over the target's repository (Target.Repo).
Package vulncheck finds known, reachable vulnerabilities in a Go module's dependencies by running govulncheck over the target's repository (Target.Repo).
Package core defines the shared types every part of Scout speaks: the unified Finding model, checks, modes, categories, targets and scan results.
Package core defines the shared types every part of Scout speaks: the unified Finding model, checks, modes, categories, targets and scan results.
Package engine runs scans: it selects checks permitted by the environment's mode cap, executes them against in-scope targets and streams findings.
Package engine runs scans: it selects checks permitted by the environment's mode cap, executes them against in-scope targets and streams findings.
examples
gin-mount command
Command gin-mount is a minimal Gin application that mounts Scout with one line.
Command gin-mount is a minimal Gin application that mounts Scout with one line.
Package integrations connects Scout to its sibling tools, Pulse (observability) and Sentinel (runtime defense).
Package integrations connects Scout to its sibling tools, Pulse (observability) and Sentinel (runtime defense).
Package intel provides vulnerability intelligence: it matches a software bill of materials (packages + versions) against known-vulnerability databases.
Package intel provides vulnerability intelligence: it matches a software bill of materials (packages + versions) against known-vulnerability databases.
stack
Package stack detects a target's technology stack — languages, frameworks, runtimes — from a repo's manifests and from a running app's fingerprint findings.
Package stack detects a target's technology stack — languages, frameworks, runtimes — from a repo's manifests and from a running app's fingerprint findings.
Package oob provides an out-of-band application security testing (OAST) listener: a small HTTP server that Scout points a payload's callback URL at, so a *blind* vulnerability — blind SSRF, blind command injection, XXE — is confirmed by observing the target call back, correlated by a unique token.
Package oob provides an out-of-band application security testing (OAST) listener: a small HTTP server that Scout points a payload's callback URL at, so a *blind* vulnerability — blind SSRF, blind command injection, XXE — is confirmed by observing the target call back, correlated by a unique token.
Package remediation renders deterministic, stack-specific fix guidance for findings.
Package remediation renders deterministic, stack-specific fix guidance for findings.
Package report renders scan results: a terminal report, JSON, SARIF and diffs between scans.
Package report renders scan results: a terminal report, JSON, SARIF and diffs between scans.
Package scoring turns findings into a 0-100 score, a letter grade, per-category subscores and the "fix next" ranking.
Package scoring turns findings into a 0-100 score, a letter grade, per-category subscores and the "fix next" ranking.
Package selftest signs and verifies the X-Scout-Scan header that Scout puts on every outbound scan request.
Package selftest signs and verifies the X-Scout-Scan header that Scout puts on every outbound scan request.
Package selfupdate lets the scout binary upgrade itself from GitHub Releases: it finds the latest published version, and replaces the running executable with the matching release asset for this OS/arch.
Package selfupdate lets the scout binary upgrade itself from GitHub Releases: it finds the latest published version, and replaces the running executable with the matching release asset for this OS/arch.
Package storage persists scans and findings.
Package storage persists scans and findings.
Package ui embeds the built dashboard (ui/dist) so consumers never need Node.
Package ui embeds the built dashboard (ui/dist) so consumers never need Node.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL