huntkit 0.3.0__py3-none-any.whl

huntkit/plugins/waybackurls.py

@@ -0,0 +1,29 @@
+"""waybackurls — fetch URLs from the Wayback Machine (tomnomnom).
+
+Reads a single domain from stdin, so the seed target is piped rather than
+placed on the argv.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .base import Capability, Category, InputMode, PluginContext, ToolPlugin
+
+
+class Waybackurls(ToolPlugin):
+    name = "waybackurls"
+    category = Category.URLS
+    description = "Fetch URLs from the Wayback Machine"
+    install = "go install github.com/tomnomnom/waybackurls@latest"
+    consumes = Capability.DOMAIN
+    produces = Capability.URL
+    input_mode = InputMode.TARGET  # single seed, fed via stdin below
+
+    def build_args(self, ctx: PluginContext) -> list[str]:
+        return []
+
+    def stdin_payload(self, ctx: PluginContext) -> Optional[str]:
+        if ctx.target:
+            return ctx.target
+        return "\n".join(ctx.inputs) if ctx.inputs else None

huntkit/plugins/whatweb.py

@@ -0,0 +1,19 @@
+"""whatweb — technology fingerprinting."""
+
+from __future__ import annotations
+
+from .base import Capability, Category, InputMode, PluginContext, ToolPlugin
+
+
+class WhatWeb(ToolPlugin):
+    name = "whatweb"
+    category = Category.RESOLVE
+    description = "Technology fingerprinting"
+    install = "sudo apt install whatweb"
+    consumes = Capability.URL
+    produces = Capability.FINDING
+    input_mode = InputMode.ARGS
+
+    def build_args(self, ctx: PluginContext) -> list[str]:
+        # one fingerprint line per target; targets given as argv
+        return ["--no-errors", "--colour=never", "-q", *ctx.inputs]

huntkit/report/__init__.py

@@ -0,0 +1,103 @@
+"""Reporting layer — turn a scored workspace into a shareable report.
+
+A composition feature layer over ``intel`` and ``knowledge``: :func:`build`
+assembles the :class:`~huntkit.report.builder.Report`, :mod:`render` turns it
+into Markdown / HTML / JSON, and :func:`write` persists it under the
+workspace's ``reports/`` directory. PDF is best-effort — with the optional
+``weasyprint`` backend it renders a PDF, otherwise it writes the print-ready
+HTML and says so, keeping the core dependency-light.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..core.workspace import Workspace
+from ..utils import filesystem as fs
+from ..utils.validators import sanitize_filename
+from . import render
+from .builder import Report, Screenshot, build
+
+# Canonical output formats.
+FORMATS = ("md", "html", "json", "pdf")
+_ALIASES = {
+    "md": "md",
+    "markdown": "md",
+    "html": "html",
+    "htm": "html",
+    "json": "json",
+    "pdf": "pdf",
+}
+
+
+def normalise_format(fmt: str) -> str | None:
+    """Map a user-supplied format onto a canonical one, or None if unknown."""
+    return _ALIASES.get(fmt.strip().lower())
+
+
+@dataclass
+class Written:
+    """Where a report landed, plus an optional note (e.g. PDF degraded to HTML)."""
+
+    path: Path
+    note: str = ""
+
+
+def _default_path(ws: Workspace, ext: str) -> Path:
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    return ws.path("reports", f"{sanitize_filename(ws.program)}-{stamp}.{ext}")
+
+
+_RENDERERS = {
+    "md": render.to_markdown,
+    "html": render.to_html,
+    "json": render.to_json,
+}
+
+
+def write(ws: Workspace, report: Report, fmt: str, out: Path | None = None) -> Written:
+    """Render ``report`` as ``fmt`` (canonical) and write it to disk."""
+    if fmt == "pdf":
+        return _write_pdf(ws, report, out)
+    target = out or _default_path(ws, fmt)
+    fs.write_text(target, _RENDERERS[fmt](report))
+    return Written(target)
+
+
+def _write_pdf(ws: Workspace, report: Report, out: Path | None) -> Written:
+    html = render.to_html(report)
+    target = out or _default_path(ws, "pdf")
+    try:
+        import weasyprint
+    except Exception:
+        # No PDF backend: write the print-ready HTML and tell the user.
+        fallback = target.with_suffix(".html")
+        fs.write_text(fallback, html)
+        return Written(
+            fallback,
+            "no PDF backend (install `weasyprint`) — wrote print-ready HTML "
+            "instead; open it and use Print → Save as PDF.",
+        )
+    fs.ensure_dir(target.parent)  # pragma: no cover
+    weasyprint.HTML(string=html).write_pdf(str(target))  # pragma: no cover
+    return Written(target)  # pragma: no cover
+
+
+def generate(ws: Workspace, fmt: str = "md", out: Path | None = None) -> Written:
+    """Build the report and write it in one call."""
+    return write(ws, build(ws), fmt, out)
+
+
+__all__ = [
+    "FORMATS",
+    "Report",
+    "Screenshot",
+    "Written",
+    "build",
+    "generate",
+    "normalise_format",
+    "render",
+    "write",
+]

huntkit/report/builder.py

@@ -0,0 +1,145 @@
+"""Assemble an engagement report from everything a workspace holds.
+
+A :class:`Report` is the composition layer: it runs the intelligence engine
+over the recon surface, pulls the referenced playbooks out of the knowledge
+base, and pairs them with scope and recon counts. The renderers
+(:mod:`huntkit.report.render`) turn this one model into Markdown, HTML, or
+JSON, so every format shows exactly the same facts.
+
+Pure and offline — it only reads artifacts already on disk.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import time
+from dataclasses import dataclass, field
+
+from ..core.workspace import Workspace
+from ..intel import IntelReport, analyze
+from ..knowledge import Playbook, get_playbook
+
+# Recon artifacts summarised in the report, in pipeline order.
+_RECON_FILES: tuple[tuple[str, str], ...] = (
+    ("subdomains", "recon/subdomains.txt"),
+    ("resolved", "recon/resolved.txt"),
+    ("live", "recon/live.txt"),
+    ("ports", "recon/ports.txt"),
+    ("urls", "urls/urls.txt"),
+)
+
+_SHOTS_MANIFEST = "scans/screenshots.json"
+_MIME = {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg"}
+
+
+@dataclass
+class Screenshot:
+    """One captured URL and, for the HTML renderer, its inlined image.
+
+    ``data_uri`` is populated by the builder (which can read the file) so the
+    HTML report stays a single self-contained page; it is deliberately left
+    out of :meth:`to_dict` so JSON/Markdown reference the file by path.
+    """
+
+    url: str
+    file: str  # relative to the workspace root
+    data_uri: str = ""
+
+    def to_dict(self) -> dict:
+        return {"url": self.url, "file": self.file}
+
+
+@dataclass
+class Report:
+    program: str
+    scope_in: list[str]
+    scope_out: list[str]
+    recon: dict[str, int]  # stage -> asset count
+    intel: IntelReport
+    playbooks: list[Playbook]  # referenced by attack paths, severity order
+    screenshots: list[Screenshot] = field(default_factory=list)
+    generated: float = field(default_factory=time.time)
+
+    @property
+    def has_findings(self) -> bool:
+        return bool(self.intel.signals)
+
+    @property
+    def has_data(self) -> bool:
+        """True if there is anything worth writing — findings or recon assets."""
+        return self.has_findings or any(self.recon.values())
+
+    def to_dict(self) -> dict:
+        return {
+            "program": self.program,
+            "generated": self.generated,
+            "scope": {"in": self.scope_in, "out": self.scope_out},
+            "recon": self.recon,
+            "intel": self.intel.to_dict(),
+            "playbooks": [p.to_dict() for p in self.playbooks],
+            "screenshots": [s.to_dict() for s in self.screenshots],
+        }
+
+
+def _referenced_playbooks(intel: IntelReport) -> list[Playbook]:
+    """The playbooks the attack paths point at, most-severe first, de-duped."""
+    out: list[Playbook] = []
+    seen: set[str] = set()
+    for path in intel.attack_paths():  # already severity-ranked
+        if path.playbook in seen:
+            continue
+        pb = get_playbook(path.playbook)
+        if pb is not None:
+            out.append(pb)
+            seen.add(path.playbook)
+    return out
+
+
+def _load_screenshots(ws: Workspace) -> list[Screenshot]:
+    """Read the screenshot manifest and inline each image for the HTML report.
+
+    Missing or malformed manifests yield no screenshots; an image file that
+    has gone missing is dropped rather than erroring the whole report.
+    """
+    manifest = ws.path(_SHOTS_MANIFEST)
+    if not manifest.exists():
+        return []
+    try:
+        data = json.loads(manifest.read_text(encoding="utf-8"))
+        entries = data.get("shots", [])
+    except (ValueError, OSError):
+        return []
+
+    out: list[Screenshot] = []
+    for entry in entries:
+        rel = entry.get("file", "")
+        url = entry.get("url", "")
+        if not rel or not url:
+            continue
+        shot = Screenshot(url=url, file=rel)
+        img = ws.path(rel)
+        mime = _MIME.get(img.suffix.lower())
+        if mime and img.exists():
+            try:
+                raw = base64.b64encode(img.read_bytes()).decode("ascii")
+                shot.data_uri = f"data:{mime};base64,{raw}"
+            except OSError:
+                pass
+        out.append(shot)
+    return out
+
+
+def build(ws: Workspace) -> Report:
+    """Score the workspace and gather everything a report needs."""
+    intel = analyze(ws)
+    recon = {label: ws.count(rel) for label, rel in _RECON_FILES}
+    return Report(
+        program=ws.program,
+        scope_in=ws.scope_in,
+        scope_out=ws.scope_out,
+        recon=recon,
+        intel=intel,
+        playbooks=_referenced_playbooks(intel),
+        screenshots=_load_screenshots(ws),
+    )

huntkit/report/render.py

@@ -0,0 +1,323 @@
+"""Render a :class:`~huntkit.report.builder.Report` to Markdown, HTML, or JSON.
+
+Each renderer walks the same model, so the three formats never disagree.
+Markdown is the canonical, diff-friendly format; HTML is a self-contained,
+print-ready page (inline CSS, no external assets); JSON is the machine form.
+"""
+
+from __future__ import annotations
+
+import html as _html
+import json
+import time
+from collections.abc import Sequence
+
+from ..intel import Signal
+from ..knowledge import Playbook
+from .builder import Report
+
+_GEN_BY = "Generated by HuntKit — for authorised testing only."
+
+
+def _ts(epoch: float) -> str:
+    return time.strftime("%Y-%m-%d %H:%M UTC", time.gmtime(epoch))
+
+
+def _notable(report: Report) -> list[Signal]:
+    """High/Critical single signals — the infra exposures worth calling out."""
+    return sorted(
+        (s for s in report.intel.signals if int(s.severity) >= 4),
+        key=lambda s: (-int(s.severity), s.host),
+    )
+
+
+# ---------------------------------------------------------------------------
+# JSON
+# ---------------------------------------------------------------------------
+def to_json(report: Report) -> str:
+    return json.dumps(report.to_dict(), indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Markdown
+# ---------------------------------------------------------------------------
+def _md_table(headers: list[str], rows: Sequence[tuple[str, ...]]) -> list[str]:
+    out = ["| " + " | ".join(headers) + " |", "| " + " | ".join("---" for _ in headers) + " |"]
+    out += ["| " + " | ".join(row) + " |" for row in rows]
+    out.append("")
+    return out
+
+
+def to_markdown(report: Report) -> str:
+    intel = report.intel
+    out: list[str] = [
+        f"# HuntKit Report — {report.program}",
+        "",
+        f"_Generated {_ts(report.generated)}_",
+        "",
+    ]
+    if report.scope_in:
+        out.append(f"**In scope:** {', '.join(report.scope_in)}")
+    if report.scope_out:
+        out.append(f"**Out of scope:** {', '.join(report.scope_out)}")
+    out.append("")
+
+    out += ["## Summary", ""]
+    out += _md_table(["Priority", "Hosts"], [(label, str(n)) for label, n in intel.summary.items()])
+    out += [f"{len(intel.signals)} signals across {len(intel.hosts)} hosts.", ""]
+
+    if intel.hosts:
+        out += ["## Prioritised hosts", ""]
+        out += _md_table(
+            ["Host", "Priority", "Score", "Signals", "Playbooks"],
+            [
+                (
+                    h.host,
+                    h.priority.label,
+                    str(h.score),
+                    str(len(h.signals)),
+                    ", ".join(h.playbooks[:4]) or "—",
+                )
+                for h in intel.hosts
+            ],
+        )
+
+    paths = intel.attack_paths()
+    if paths:
+        out += ["## Attack paths", ""]
+        rows = []
+        for p in paths:
+            where = ", ".join(p.hosts[:4]) + (" …" if len(p.hosts) > 4 else "")
+            rows.append((p.name, f"`{p.playbook}`", p.severity.label, str(len(p.hosts)), where))
+        out += _md_table(["Playbook", "id", "Severity", "Hosts", "Where"], rows)
+
+    hot = _notable(report)
+    if hot:
+        out += ["## Notable exposures", ""]
+        out += _md_table(
+            ["Severity", "Host", "Finding", "Evidence"],
+            [(s.severity.label, s.host, s.title, s.evidence) for s in hot],
+        )
+
+    if report.screenshots:
+        out += ["## Screenshots", ""]
+        out += [f"- [{s.url}]({s.file})" for s in report.screenshots]
+        out += [""]
+
+    out += ["## Recon surface", ""]
+    out += _md_table(["Stage", "Count"], [(label, str(n)) for label, n in report.recon.items()])
+
+    if report.playbooks:
+        out += [
+            "## Playbooks",
+            "",
+            "The bug classes this surface points at, in priority order.",
+            "",
+        ]
+        for pb in report.playbooks:
+            out.append(pb.to_markdown(level=3))
+            out.append("")
+
+    out += ["---", "", _GEN_BY]
+    return "\n".join(out).rstrip() + "\n"
+
+
+# ---------------------------------------------------------------------------
+# HTML
+# ---------------------------------------------------------------------------
+_CSS = """
+:root { --bg:#ffffff; --fg:#1f2933; --muted:#6b7280; --line:#e5e7eb; --accent:#0f766e; }
+* { box-sizing: border-box; }
+body { margin:0; background:var(--bg); color:var(--fg);
+  font:15px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Helvetica,Arial,sans-serif; }
+.wrap { max-width: 900px; margin: 0 auto; padding: 40px 24px 80px; }
+h1 { font-size: 1.9rem; margin: 0 0 4px; }
+h1 .muted { font-weight: 400; }
+h2 { font-size: 1.25rem; margin: 2.2rem 0 .8rem; padding-bottom:.3rem; border-bottom:2px solid var(--line); }
+h3 { font-size: 1.05rem; margin: 1.6rem 0 .4rem; }
+h4 { font-size: .8rem; text-transform: uppercase; letter-spacing:.04em; color: var(--muted); margin: 1rem 0 .3rem; }
+p { margin: .5rem 0; }
+.meta, .muted { color: var(--muted); }
+.meta { margin: 2px 0; font-size: .9rem; }
+code { background:#f3f4f6; padding:1px 5px; border-radius:4px; font-size:.85em; }
+a { color: var(--accent); }
+table { border-collapse: collapse; width:100%; margin:.4rem 0 1rem; font-size:.9rem; }
+th, td { text-align:left; padding:7px 10px; border-bottom:1px solid var(--line); vertical-align:top; }
+th { font-size:.72rem; text-transform:uppercase; letter-spacing:.04em; color:var(--muted); }
+tbody tr:hover { background:#fafafa; }
+pre { background:#0f172a; color:#e2e8f0; padding:12px 14px; border-radius:8px; overflow-x:auto;
+  font:13px/1.5 "SF Mono",ui-monospace,Menlo,Consolas,monospace; }
+ul { margin:.3rem 0; padding-left:1.2rem; }
+li { margin:.15rem 0; }
+.cards { display:flex; gap:12px; flex-wrap:wrap; margin:.6rem 0 1rem; }
+.card { flex:1; min-width:110px; border:1px solid var(--line); border-radius:10px; padding:14px 16px; }
+.card-n { font-size:1.8rem; font-weight:700; line-height:1; }
+.card-l { font-size:.8rem; color:var(--muted); margin-top:4px; }
+.card-critical { border-color:#7f1d1d; } .card-critical .card-n { color:#7f1d1d; }
+.card-high { border-color:#dc2626; } .card-high .card-n { color:#dc2626; }
+.card-medium { border-color:#d97706; } .card-medium .card-n { color:#b45309; }
+.card-low { border-color:#16a34a; } .card-low .card-n { color:#15803d; }
+.sev { display:inline-block; padding:1px 8px; border-radius:999px; font-size:.75rem; font-weight:600; }
+.sev-critical { background:#7f1d1d; color:#fff; }
+.sev-high { background:#fee2e2; color:#991b1b; }
+.sev-medium { background:#ffedd5; color:#9a3412; }
+.sev-low { background:#dcfce7; color:#166534; }
+.sev-informational { background:#e0f2fe; color:#075985; }
+.pb { border:1px solid var(--line); border-radius:12px; padding:4px 20px 16px; margin:1rem 0; }
+.gallery { display:grid; grid-template-columns:repeat(auto-fill,minmax(240px,1fr)); gap:14px; margin:.6rem 0 1rem; }
+.gallery figure { margin:0; border:1px solid var(--line); border-radius:10px; overflow:hidden; }
+.gallery img { display:block; width:100%; height:160px; object-fit:cover; object-position:top; background:#f3f4f6; }
+.gallery figcaption { padding:7px 10px; font-size:.78rem; color:var(--muted); word-break:break-all; border-top:1px solid var(--line); }
+footer { margin-top:3rem; padding-top:1rem; border-top:1px solid var(--line); color:var(--muted); font-size:.85rem; }
+@media (prefers-color-scheme: dark) {
+  :root { --bg:#0b1220; --fg:#e5e7eb; --muted:#9ca3af; --line:#1f2937; --accent:#5eead4; }
+  code { background:#1f2937; } tbody tr:hover { background:#111827; }
+  .sev-high { background:#450a0a; color:#fca5a5; } .sev-medium { background:#451a03; color:#fdba74; }
+  .sev-low { background:#052e16; color:#86efac; } .sev-informational { background:#082f49; color:#7dd3fc; }
+}
+@media print { .pb, .card { break-inside: avoid; } body { background:#fff; color:#000; } }
+"""
+
+
+def _chip(sev) -> str:
+    return f"<span class='sev sev-{sev.style}'>{_html.escape(sev.label)}</span>"
+
+
+def _html_table(headers: list[str], rows: Sequence[tuple[str, ...]]) -> str:
+    head = "".join(f"<th>{_html.escape(h)}</th>" for h in headers)
+    body = "".join("<tr>" + "".join(f"<td>{c}</td>" for c in row) + "</tr>" for row in rows)
+    return f"<table><thead><tr>{head}</tr></thead><tbody>{body}</tbody></table>"
+
+
+def _playbook_html(pb: Playbook) -> str:
+    p: list[str] = [
+        "<section class='pb'>",
+        f"<h3>{_html.escape(pb.title)} {_chip(pb.severity)} "
+        f"<code>{_html.escape(pb.id)}</code></h3>",
+        f"<p>{_html.escape(pb.summary)}</p>",
+        f"<p class='muted'><strong>When:</strong> {_html.escape(pb.when)}</p>",
+    ]
+
+    def block(head: str, items: tuple[str, ...]) -> None:
+        if not items:
+            return
+        p.append(f"<h4>{head}</h4><ul>")
+        p.extend(f"<li>{_html.escape(it)}</li>" for it in items)
+        p.append("</ul>")
+
+    block("Detection", pb.detection)
+    if pb.payloads:
+        p.append("<h4>Payloads</h4><pre>" + _html.escape("\n".join(pb.payloads)) + "</pre>")
+    block("Bypasses", pb.bypasses)
+    if pb.tools:
+        p.append("<h4>Go-to tools</h4><p>" + _html.escape(", ".join(pb.tools)) + "</p>")
+    if pb.references:
+        p.append("<h4>References</h4><ul>")
+        p += [
+            f"<li><a href='{_html.escape(r.url)}'>{_html.escape(r.name)}</a></li>"
+            for r in pb.references
+        ]
+        p.append("</ul>")
+    p.append("</section>")
+    return "".join(p)
+
+
+def to_html(report: Report) -> str:
+    intel = report.intel
+    esc = _html.escape
+    h: list[str] = [
+        "<!doctype html>",
+        '<html lang="en"><head><meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        f"<title>HuntKit Report — {esc(report.program)}</title>",
+        f"<style>{_CSS}</style>",
+        "</head><body><main class='wrap'>",
+        f"<h1>HuntKit Report <span class='muted'>— {esc(report.program)}</span></h1>",
+        f"<p class='meta'>Generated {_ts(report.generated)}</p>",
+    ]
+    if report.scope_in:
+        h.append(
+            f"<p class='meta'><strong>In scope:</strong> {esc(', '.join(report.scope_in))}</p>"
+        )
+    if report.scope_out:
+        h.append(
+            f"<p class='meta'><strong>Out of scope:</strong> {esc(', '.join(report.scope_out))}</p>"
+        )
+
+    h.append("<h2>Summary</h2><div class='cards'>")
+    for label, n in intel.summary.items():
+        h.append(
+            f"<div class='card card-{label.lower()}'>"
+            f"<div class='card-n'>{n}</div><div class='card-l'>{label}</div></div>"
+        )
+    h.append("</div>")
+    h.append(f"<p>{len(intel.signals)} signals across {len(intel.hosts)} hosts.</p>")
+
+    if intel.hosts:
+        h.append("<h2>Prioritised hosts</h2>")
+        h.append(
+            _html_table(
+                ["Host", "Priority", "Score", "Signals", "Playbooks"],
+                [
+                    (
+                        esc(x.host),
+                        _chip(x.priority),
+                        str(x.score),
+                        str(len(x.signals)),
+                        esc(", ".join(x.playbooks[:4]) or "—"),
+                    )
+                    for x in intel.hosts
+                ],
+            )
+        )
+
+    paths = intel.attack_paths()
+    if paths:
+        h.append("<h2>Attack paths</h2>")
+        rows = []
+        for p in paths:
+            where = esc(", ".join(p.hosts[:4])) + (" …" if len(p.hosts) > 4 else "")
+            rows.append(
+                (
+                    esc(p.name),
+                    f"<code>{esc(p.playbook)}</code>",
+                    _chip(p.severity),
+                    str(len(p.hosts)),
+                    where,
+                )
+            )
+        h.append(_html_table(["Playbook", "id", "Severity", "Hosts", "Where"], rows))
+
+    hot = _notable(report)
+    if hot:
+        h.append("<h2>Notable exposures</h2>")
+        h.append(
+            _html_table(
+                ["Severity", "Host", "Finding", "Evidence"],
+                [(_chip(s.severity), esc(s.host), esc(s.title), esc(s.evidence)) for s in hot],
+            )
+        )
+
+    shots = [s for s in report.screenshots if s.data_uri]
+    if shots:
+        h.append("<h2>Screenshots</h2><div class='gallery'>")
+        for s in shots:
+            h.append(
+                f"<figure><img loading='lazy' src='{s.data_uri}' alt='{esc(s.url)}'>"
+                f"<figcaption>{esc(s.url)}</figcaption></figure>"
+            )
+        h.append("</div>")
+
+    h.append("<h2>Recon surface</h2>")
+    h.append(
+        _html_table(["Stage", "Count"], [(esc(label), str(n)) for label, n in report.recon.items()])
+    )
+
+    if report.playbooks:
+        h.append("<h2>Playbooks</h2>")
+        h.append("<p class='muted'>The bug classes this surface points at, in priority order.</p>")
+        h += [_playbook_html(pb) for pb in report.playbooks]
+
+    h.append(f"<footer>{esc(_GEN_BY)}</footer>")
+    h.append("</main></body></html>")
+    return "\n".join(h) + "\n"

huntkit/scanner/__init__.py

@@ -0,0 +1,28 @@
+"""Active scanning layer.
+
+Drives the ``SCAN``-category plugins over the URLs recon gathered, writing
+findings to the workspace's ``scans/`` directory. See :mod:`huntkit.scanner.
+runner` for the contract; the public surface is :func:`run_scan`.
+"""
+
+from __future__ import annotations
+
+from .runner import (
+    FINDINGS_JSON,
+    Scanner,
+    ScanOutcome,
+    ScanSummary,
+    run_scan,
+    scan_plugins,
+    scan_targets,
+)
+
+__all__ = [
+    "FINDINGS_JSON",
+    "ScanOutcome",
+    "ScanSummary",
+    "Scanner",
+    "run_scan",
+    "scan_plugins",
+    "scan_targets",
+]