Skip to content

Back to the catalog

deep-scan
github.comrepo

deep-scan

deep-scan is a modular security-scanning monorepo exposing one shared scanner engine (SAST, SCA, secrets, IaC, license, malware, DAST, CI/CD checks) through a CLI, MCP server, REST API/web app, and a continuous-scanning ASPM fleet called kruncher. It adds a deterministic, AI-free code-graph engine for taint and reachability analysis to cut CVE noise to actually-reachable dependencies, an optional local-model AI triage pass, and an agent-driven MCP workflow that scans, confirms reachability, and opens fix-group PR branches with regression tests. Untrusted-repo scanning is hardened with pinned/checksum-verified tools, sandboxed subprocesses, and optional gVisor (runsc) isolation for dependency resolution on Kubernetes.

TL;DR Unified open-source scanner (SAST/SCA/secrets/IaC/DAST) with an MCP agent that triages reachable findings and auto-opens fix PRs, plus a gVisor-sandboxed ASPM fleet for scanning untrusted repos.
Document

What it is

deep-scan (kubeek-sec/deep-scan) is a Python 3.13 uv workspace. Beyond the architecture the summary already covers, the page gives the concrete entry points for actually standing it up and evaluating it — install order, scan invocations, a CI gate, a bundled vulnerable test target, and a one-command full-stack deploy.

How it works

All front-ends (CLI, MCP, REST/web app, kruncher fleet) share one engine, one normalized Finding model, (location, message) deduplication, and four report formats: JSON, Markdown, HTML, SARIF 2.1.0. Scans auto-detect static (directory) vs. dynamic (running URL). Reports land in reports/scan_<timestamp>_<mode>/report.{json,md,html,sarif}.

What to do

Install, then fetch pinned checksum-verified tools (this step is required before scanning):

uv sync
uv run deepscan tools install all

Scan a directory or a running URL; run the offline AI-free taint engine alone; or use as a CI gate:

uv run deepscan scan ./my-project
uv run deepscan scan http://127.0.0.1:3000
uv run deepscan scan ./my-project --scanner analysis
uv run deepscan scan ./my-project --fail-on high

--fail-on high exits 1 on a HIGH+ finding. A deliberately-vulnerable project with ground-truth findings ships for validation:

uv run deepscan scan ./guinea-pig

Bring up the whole stack (Postgres, kruncher, REST/web, MCP, ASPM), scaling workers to 4:

cp deploy/docker/.env.example deploy/docker/.env
docker compose -f deploy/docker/docker-compose.yml up --build --scale kruncher=4

(or ./start.sh). Then: web/REST http://127.0.0.1:8800/, ASPM http://127.0.0.1:8900/, MCP http://127.0.0.1:8000/mcp. To verify the sandboxing end-to-end without a real cluster, ./k8s-test.sh spins up an ephemeral kind cluster.

Preconditions / Affected

Full sandbox hardening (non-root, read-only rootfs, all capabilities dropped, RuntimeDefault seccomp, no service-account token, default-deny egress, optional gVisor runsc) is described as Kubernetes behavior, requiring a gvisor RuntimeClass pinned to a tainted sandbox node pool. The isolated dependency-resolution container needs an internal package mirror to restrict egress to. Docker Compose gets you the stack but not this Kubernetes hardening.

Caveats

The code-graph engine (taint, reachability, choke points) is explicitly labeled work-in-progress ("wip") on the page. AI triage is optional and read-only. The page repeatedly stresses that scanning untrusted repos is inherently dangerous — dependency resolution runs arbitrary package-manager code — so the hardening is a mitigation you must enable and verify (per docs/sandboxing.md), not a default of the simple uv run path.

Techniques named here

  • SAST
  • SCA
  • Secrets scanning
  • IaC scanning
  • License scanning
  • Malware scanning
  • DAST
  • CI/CD pipeline checks
  • Deterministic, AI-free code-graph security analysis
  • reachable-deps
  • query_graph for confirming reachability of findings
  • Finding deduplication via model
  • Agent-driven remediation loop