attackmap 0.4.5__tar.gz → 0.4.10__tar.gz

{attackmap-0.4.5/src/attackmap.egg-info → attackmap-0.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attackmap
-Version: 0.4.5
+Version: 0.4.10
 Summary: AI-assisted defensive security analyzer for codebases — scans a repository, models assets and controls, finds cross-cutting weaknesses, and generates an evidence-grounded review with MITRE ATT&CK mappings and detection-engineering hints.
 Author: AttackMap Contributors
 Author-email: Matthew Davis <matthewd@matthewd.xyz>
@@ -34,6 +34,7 @@ License-File: LICENSE
 Requires-Dist: typer>=0.12.3
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: networkx>=3.3
+Requires-Dist: PyYAML>=6.0
 Provides-Extra: llm
 Requires-Dist: anthropic>=0.40.0; extra == "llm"
 Requires-Dist: openai>=1.60.0; extra == "llm"
@@ -271,6 +272,48 @@ on unrelated commits, so a finding that persists across scans has the same id
 in both. The diff has three sections — **New**, **Persisted**, **Resolved** —
 which drop cleanly into a PR comment.
 
+### Suppressing findings
+
+Silence a residual false positive without going blind to new signal. Two
+mechanisms, both honored across every pass:
+
+**Repo-level baseline** — `.attackmap-suppress.yaml` at the repo root:
+
+```yaml
+version: 1
+suppress:
+  # by stable finding id (the 16-hex id in attackmap-report.json)
+  - id: 1a2b3c4d5e6f7a8b
+    reason: accepted risk, tracked in JIRA-1234
+
+  # by rule (a slug of the finding title — same string as the SARIF ruleId),
+  # optionally scoped to paths
+  - rule: hard-coded-secret-literals-were-found-in-source-or-config
+    reason: example keys in docs, never shipped
+    paths: ["docs/**", "examples/**"]
+
+  # by path only — any finding whose evidence is *entirely* within these globs
+  - path: "vendor/**"
+    reason: third-party code, out of scope
+```
+
+A `path` selector matches a finding only when **every** file its evidence cites
+falls under the glob, so a finding that also touches live code is never hidden.
+`*` spans path separators (`vendor/*` covers the whole subtree).
+
+**Inline directives** — a comment on the flagged line, in any language:
+
+```python
+API_KEY = "AKIA…"  # attackmap:ignore[hard-coded-secret-literals-were-found-in-source-or-config] staging only
+```
+
+Suppressed findings are **not dropped**: they're excluded from
+`--fail-on-new-high` and the console summary, but retained in
+`attackmap-report.json` under `suppressed_findings` (with reasons) and marked
+with a SARIF `suppressions` array so GitHub Code Scanning shows them as
+suppressed. Suppression counts print in the run summary. Use `--no-suppress`
+for a full unfiltered audit, or `--suppress-file PATH` to point elsewhere.
+
 ### Data-flow / injection detection
 
 A lightweight taint pass (Python + JS/TS) walks the import graph up to two hops
@@ -306,6 +349,19 @@ template is not flagged. It's a heuristic (import-edge ≠ call-edge), so findin
 are evidence, not proof; confidence tapers with hop distance. Chains appear in
 `attackmap-report.json` under `scan.taint_chains`.
 
+**Sanitizer awareness.** When a sink-appropriate neutralizer is present in the
+sink file — `shlex.quote` / `escapeshellarg` (shell), `secure_filename` / path
+allow-listers (`open`), `is_safe_url` (redirect), `markupsafe.escape` (SSTI),
+driver escapers (SQL), mongo-sanitize (NoSQL) — the chain is marked
+`sanitized`, its confidence is downgraded well below the finding threshold, and
+the neutralizer is recorded in `sanitizer_evidence`. Sanitized chains stay in
+`scan.taint_chains` for audit but don't raise a HIGH finding or earn an
+exploitability score. Detection is file-granular (matching the import-walk's
+granularity), so it trades a little recall for precision. To extend the table,
+add a high-signal, sink-appropriate `(label, regex)` entry to
+`_SANITIZER_PATTERNS` in [`taint.py`](src/attackmap/taint.py) — keep it specific
+(a vague `validate(` would hide real bugs).
+
 Test and spec files (`tests/`, `__tests__/`, `*.test.*`, `test_*.py`, …) are
 excluded from all the heuristic passes above by default, since dangerous
 patterns in test scaffolding are rarely real exposure. Set
@@ -347,6 +403,40 @@ identifier; cipher/ECB tokens are matched case-sensitively so algorithm names
 aren't confused with prose (e.g. the French word "des"). Results appear under
 `scan.crypto_weaknesses`.
 
+### GitHub Actions / CI workflow security
+
+CI config is a real attack surface. AttackMap parses `.github/workflows/*.yml`
+and flags supply-chain and code-execution risks, each a finding with an ATT&CK
+mapping:
+
+| Kind | Catches | Severity |
+|---|---|---|
+| `script_injection` | attacker-controlled context (`github.event.*.{title,body,message,…}`, `github.head_ref`) interpolated into a `run:` step | HIGH |
+| `pr_target_checkout` | `pull_request_target` + checkout of the PR head ref (untrusted code with secrets in scope) | HIGH |
+| `unpinned_action` | `uses: org/action@tag\|branch` instead of a pinned commit SHA | branch = MEDIUM, semver tag = LOW |
+| `secret_in_run` | `${{ secrets.* }}` expanded into a shell step (pass via `env:` instead) | MEDIUM |
+| `broad_permissions` | `permissions: write-all` at workflow or job level | MEDIUM |
+| `self_hosted_pr` | self-hosted runner on a `pull_request`/`pull_request_target` trigger | HIGH / MEDIUM |
+
+A hardened workflow — SHA-pinned actions, scoped `permissions:`, secrets via
+`env:`, no untrusted-context interpolation — produces nothing. Results appear
+under `scan.workflow_issues`.
+
+### Unauthenticated state-changing routes
+
+Raw `auth_hints` are signals, not conclusions — a monorepo emits hundreds. A
+fusion pass turns them into one precise finding: the public, state-changing
+(`POST/PUT/PATCH/DELETE`) routes with **no auth control on their own chain**. It
+resolves the control *per route* rather than by file proximity:
+
+- **Express/Koa/Fastify** — auth middleware in the route's arguments, or a global `app.use(...)` / `router.use(...)`.
+- **FastAPI/Flask** — an auth decorator, `dependencies=[Depends(...)]`, `Depends(<auth>)` / `Security(...)` in the signature, or a router-level dependency.
+- **Spring** — `@PreAuthorize` / `@Secured` / `@RolesAllowed` on the method or controller, or a global "authenticated" policy.
+
+Routes behind a control produce nothing, and the sensitive categories
+(webhook/admin/upload/auth) keep their own dedicated findings — so this only
+adds the general mutating-endpoint case, with the resolved chain as evidence.
+
 ### Broken object-level authorization (BOLA / IDOR)
 
 OWASP API Security #1. AttackMap flags a route as a BOLA/IDOR candidate when it
@@ -562,6 +652,10 @@ attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for
 attackmap analyze <path> --baseline prev/attackmap-report.json \
   --diff-output reports/attackmap-diff.md --fail-on-new-high
 
+# Suppression (.attackmap-suppress.yaml + inline `attackmap:ignore` directives)
+attackmap analyze <path> --no-suppress          # full audit, ignore all suppressions
+attackmap analyze <path> --suppress-file cfg.yaml   # override baseline location
+
 # Plugin discovery
 attackmap suggest ./repo                 # recommend plugins for a repo shape
 attackmap suggest ./repo --install       # and pip-install the missing ones

{attackmap-0.4.5 → attackmap-0.4.10}/README.md

@@ -211,6 +211,48 @@ on unrelated commits, so a finding that persists across scans has the same id
 in both. The diff has three sections — **New**, **Persisted**, **Resolved** —
 which drop cleanly into a PR comment.
 
+### Suppressing findings
+
+Silence a residual false positive without going blind to new signal. Two
+mechanisms, both honored across every pass:
+
+**Repo-level baseline** — `.attackmap-suppress.yaml` at the repo root:
+
+```yaml
+version: 1
+suppress:
+  # by stable finding id (the 16-hex id in attackmap-report.json)
+  - id: 1a2b3c4d5e6f7a8b
+    reason: accepted risk, tracked in JIRA-1234
+
+  # by rule (a slug of the finding title — same string as the SARIF ruleId),
+  # optionally scoped to paths
+  - rule: hard-coded-secret-literals-were-found-in-source-or-config
+    reason: example keys in docs, never shipped
+    paths: ["docs/**", "examples/**"]
+
+  # by path only — any finding whose evidence is *entirely* within these globs
+  - path: "vendor/**"
+    reason: third-party code, out of scope
+```
+
+A `path` selector matches a finding only when **every** file its evidence cites
+falls under the glob, so a finding that also touches live code is never hidden.
+`*` spans path separators (`vendor/*` covers the whole subtree).
+
+**Inline directives** — a comment on the flagged line, in any language:
+
+```python
+API_KEY = "AKIA…"  # attackmap:ignore[hard-coded-secret-literals-were-found-in-source-or-config] staging only
+```
+
+Suppressed findings are **not dropped**: they're excluded from
+`--fail-on-new-high` and the console summary, but retained in
+`attackmap-report.json` under `suppressed_findings` (with reasons) and marked
+with a SARIF `suppressions` array so GitHub Code Scanning shows them as
+suppressed. Suppression counts print in the run summary. Use `--no-suppress`
+for a full unfiltered audit, or `--suppress-file PATH` to point elsewhere.
+
 ### Data-flow / injection detection
 
 A lightweight taint pass (Python + JS/TS) walks the import graph up to two hops
@@ -246,6 +288,19 @@ template is not flagged. It's a heuristic (import-edge ≠ call-edge), so findin
 are evidence, not proof; confidence tapers with hop distance. Chains appear in
 `attackmap-report.json` under `scan.taint_chains`.
 
+**Sanitizer awareness.** When a sink-appropriate neutralizer is present in the
+sink file — `shlex.quote` / `escapeshellarg` (shell), `secure_filename` / path
+allow-listers (`open`), `is_safe_url` (redirect), `markupsafe.escape` (SSTI),
+driver escapers (SQL), mongo-sanitize (NoSQL) — the chain is marked
+`sanitized`, its confidence is downgraded well below the finding threshold, and
+the neutralizer is recorded in `sanitizer_evidence`. Sanitized chains stay in
+`scan.taint_chains` for audit but don't raise a HIGH finding or earn an
+exploitability score. Detection is file-granular (matching the import-walk's
+granularity), so it trades a little recall for precision. To extend the table,
+add a high-signal, sink-appropriate `(label, regex)` entry to
+`_SANITIZER_PATTERNS` in [`taint.py`](src/attackmap/taint.py) — keep it specific
+(a vague `validate(` would hide real bugs).
+
 Test and spec files (`tests/`, `__tests__/`, `*.test.*`, `test_*.py`, …) are
 excluded from all the heuristic passes above by default, since dangerous
 patterns in test scaffolding are rarely real exposure. Set
@@ -287,6 +342,40 @@ identifier; cipher/ECB tokens are matched case-sensitively so algorithm names
 aren't confused with prose (e.g. the French word "des"). Results appear under
 `scan.crypto_weaknesses`.
 
+### GitHub Actions / CI workflow security
+
+CI config is a real attack surface. AttackMap parses `.github/workflows/*.yml`
+and flags supply-chain and code-execution risks, each a finding with an ATT&CK
+mapping:
+
+| Kind | Catches | Severity |
+|---|---|---|
+| `script_injection` | attacker-controlled context (`github.event.*.{title,body,message,…}`, `github.head_ref`) interpolated into a `run:` step | HIGH |
+| `pr_target_checkout` | `pull_request_target` + checkout of the PR head ref (untrusted code with secrets in scope) | HIGH |
+| `unpinned_action` | `uses: org/action@tag\|branch` instead of a pinned commit SHA | branch = MEDIUM, semver tag = LOW |
+| `secret_in_run` | `${{ secrets.* }}` expanded into a shell step (pass via `env:` instead) | MEDIUM |
+| `broad_permissions` | `permissions: write-all` at workflow or job level | MEDIUM |
+| `self_hosted_pr` | self-hosted runner on a `pull_request`/`pull_request_target` trigger | HIGH / MEDIUM |
+
+A hardened workflow — SHA-pinned actions, scoped `permissions:`, secrets via
+`env:`, no untrusted-context interpolation — produces nothing. Results appear
+under `scan.workflow_issues`.
+
+### Unauthenticated state-changing routes
+
+Raw `auth_hints` are signals, not conclusions — a monorepo emits hundreds. A
+fusion pass turns them into one precise finding: the public, state-changing
+(`POST/PUT/PATCH/DELETE`) routes with **no auth control on their own chain**. It
+resolves the control *per route* rather than by file proximity:
+
+- **Express/Koa/Fastify** — auth middleware in the route's arguments, or a global `app.use(...)` / `router.use(...)`.
+- **FastAPI/Flask** — an auth decorator, `dependencies=[Depends(...)]`, `Depends(<auth>)` / `Security(...)` in the signature, or a router-level dependency.
+- **Spring** — `@PreAuthorize` / `@Secured` / `@RolesAllowed` on the method or controller, or a global "authenticated" policy.
+
+Routes behind a control produce nothing, and the sensitive categories
+(webhook/admin/upload/auth) keep their own dedicated findings — so this only
+adds the general mutating-endpoint case, with the resolved chain as evidence.
+
 ### Broken object-level authorization (BOLA / IDOR)
 
 OWASP API Security #1. AttackMap flags a route as a BOLA/IDOR candidate when it
@@ -502,6 +591,10 @@ attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for
 attackmap analyze <path> --baseline prev/attackmap-report.json \
   --diff-output reports/attackmap-diff.md --fail-on-new-high
 
+# Suppression (.attackmap-suppress.yaml + inline `attackmap:ignore` directives)
+attackmap analyze <path> --no-suppress          # full audit, ignore all suppressions
+attackmap analyze <path> --suppress-file cfg.yaml   # override baseline location
+
 # Plugin discovery
 attackmap suggest ./repo                 # recommend plugins for a repo shape
 attackmap suggest ./repo --install       # and pip-install the missing ones

{attackmap-0.4.5 → attackmap-0.4.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "attackmap"
-version = "0.4.5"
+version = "0.4.10"
 description = "AI-assisted defensive security analyzer for codebases — scans a repository, models assets and controls, finds cross-cutting weaknesses, and generates an evidence-grounded review with MITRE ATT&CK mappings and detection-engineering hints."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -51,6 +51,7 @@ dependencies = [
   "typer>=0.12.3",
   "pydantic>=2.7.0",
   "networkx>=3.3",
+  "PyYAML>=6.0",
 ]
 
 [project.optional-dependencies]

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/__init__.py

@@ -1,2 +1,2 @@
 __all__ = ["__version__"]
-__version__ = "0.4.5"
+__version__ = "0.4.10"

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/cli.py

@@ -29,6 +29,7 @@ from .progress import create_progress
 from .recon_to_analysis import translate_recon
 from .report import render_console_summary, render_pr_comment, write_reports
 from .suggest import detect_ecosystems
+from .suppress import apply_suppressions, collect_suppressions
 
 app = typer.Typer(help="AttackMap: understand your system and map your attack surface.")
 
@@ -144,6 +145,16 @@ def analyze(
         "--pr-comment",
         help="Write a Markdown PR summary comment to this path (for the GitHub Action / bot to post). Includes the baseline diff and top exploitability when available.",
     ),
+    no_suppress: bool = typer.Option(
+        False,
+        "--no-suppress",
+        help="Ignore all suppressions — the .attackmap-suppress.yaml baseline and inline `attackmap:ignore` directives (#144). Use for a full, unfiltered audit.",
+    ),
+    suppress_file: str | None = typer.Option(
+        None,
+        "--suppress-file",
+        help="Path to a suppression baseline, overriding auto-discovery of .attackmap-suppress.yaml at the repo root (#144).",
+    ),
 ) -> None:
     repo_path = Path(path).resolve()
     if not repo_path.exists():
@@ -201,6 +212,31 @@ def analyze(
     attack_surface_md = summarize_attack_surface(scan, attack_surfaces)
     findings = analysis.findings
     attack_paths = analysis.attack_paths
+
+    # Finding suppression (#144): the .attackmap-suppress.yaml baseline plus
+    # inline `attackmap:ignore` directives. Suppressed findings are partitioned
+    # out of the active set used for the review, console, and the diff gate —
+    # but retained (with reasons) in report.json and marked suppressed in SARIF.
+    suppressed_findings: list = []
+    if no_suppress:
+        if suppress_file is not None:
+            typer.echo("Note: --suppress-file is ignored because --no-suppress is set.", err=True)
+    else:
+        explicit = Path(suppress_file) if suppress_file else None
+        if explicit is not None and not explicit.exists():
+            raise typer.BadParameter(f"Suppress file not found: {explicit}")
+        suppset, sup_warnings = collect_suppressions(repo_path, findings, explicit_file=explicit)
+        for warning in sup_warnings:
+            typer.echo(f"Suppression warning: {warning}", err=True)
+        outcome = apply_suppressions(findings, suppset)
+        findings = outcome.active
+        suppressed_findings = outcome.suppressed
+        if suppressed_findings:
+            typer.echo("")
+            typer.echo(f"Suppressed {len(suppressed_findings)} finding(s) (#144):")
+            for summary_line in outcome.summary_lines():
+                typer.echo(summary_line)
+
     defensive_review_md = render_defensive_review(scan, attack_surfaces, findings, attack_paths)
 
     write_reports(
@@ -221,6 +257,7 @@ def analyze(
             }
             for metadata in (get_analyzer_metadata(analyzer) for analyzer in active_analyzers)
         ],
+        suppressed=suppressed_findings,
     )
     typer.echo(render_console_summary(scan, findings, attack_paths))
     typer.echo("")

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/exploitability.py

@@ -128,6 +128,10 @@ def score_exploitability(
 
     scores: list[ExploitabilityScore] = []
     for chain in scan.taint_chains:
+        # Sanitized chains (#137) are neutralized before the sink — not
+        # "exploitable now", so they don't earn an exploitability score.
+        if chain.sanitized:
+            continue
         # Skip conventional infra/static routes — a SQL/RCE sink "reachable"
         # from robots.txt or /_health is over-linking, not an exploit.
         if is_infra_route(chain.route_path):

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/llm_review.py

@@ -197,6 +197,14 @@ def _claude_cli_available() -> bool:
     return shutil.which("claude") is not None
 
 
+def _anthropic_sdk_available() -> bool:
+    try:
+        import anthropic  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
 def _run_via_claude_cli(
     rendered_system: str,
     rendered_user: str,
@@ -412,6 +420,14 @@ def _codex_cli_available() -> bool:
     return shutil.which("codex") is not None
 
 
+def _openai_sdk_available() -> bool:
+    try:
+        import openai  # noqa: F401
+    except ImportError:
+        return False
+    return True
+
+
 def _run_via_codex_cli(
     rendered_system: str,
     rendered_user: str,
@@ -514,10 +530,18 @@ def _resolve_openai_backend(
             )
         return "cli"
     # auto
-    if client is not None or api_key or os.environ.get("OPENAI_API_KEY"):
+    if client is not None:
+        return "api"
+    has_key = bool(api_key or os.environ.get("OPENAI_API_KEY"))
+    # Prefer the API backend only when the openai SDK is importable; otherwise
+    # fall back to the `codex` CLI (needs no SDK) so a key set against an
+    # SDK-less install still works via subscription auth.
+    if has_key and _openai_sdk_available():
         return "api"
     if _codex_cli_available():
         return "cli"
+    if has_key:
+        return "api"  # no SDK and no CLI — surface the actionable SDK-missing error
     raise LlmReviewError(
         "No OpenAI backend available. Set OPENAI_API_KEY, or install the `codex` "
         "CLI and run `codex login`."
@@ -539,12 +563,23 @@ def _resolve_backend(
             )
         return "cli"
     # auto
-    if client is not None or api_key:
+    if client is not None:
         return "api"
-    if os.environ.get("ANTHROPIC_API_KEY") or os.environ.get("ANTHROPIC_AUTH_TOKEN"):
+    has_key = bool(
+        api_key
+        or os.environ.get("ANTHROPIC_API_KEY")
+        or os.environ.get("ANTHROPIC_AUTH_TOKEN")
+    )
+    # Prefer the API backend only when the SDK is actually importable. Otherwise
+    # fall back to the `claude` CLI (needs no SDK), so a key set against an
+    # SDK-less install (e.g. Homebrew, which doesn't vendor `attackmap[llm]`)
+    # still works via subscription auth instead of erroring.
+    if has_key and _anthropic_sdk_available():
         return "api"
     if _claude_cli_available():
         return "cli"
+    if has_key:
+        return "api"  # no SDK and no CLI — surface the actionable SDK-missing error
     raise LlmReviewError(
         "No LLM backend available. Set ANTHROPIC_API_KEY, set ANTHROPIC_AUTH_TOKEN, "
         "or install the `claude` CLI and run `claude login`."

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/merge.py

@@ -96,6 +96,10 @@ MERGE_SCHEMA: tuple[MergeRule, ...] = (
         "code_weaknesses",
         lambda item: (item.kind, item.file, item.line),
     ),
+    MergeRule(
+        "workflow_issues",
+        lambda item: (item.kind, item.file, item.line, item.context),
+    ),
     MergeRule(
         "anomalies",
         lambda item: (item.kind, item.route_method, item.route_path, item.route_file),

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/models.py

@@ -203,6 +203,35 @@ class WebHardeningIssue(BaseModel):
     source_analyzer: str | None = _PROVENANCE_FIELD
 
 
+class WorkflowIssue(BaseModel):
+    """A CI-workflow security issue in a GitHub Actions file (#142).
+
+    Emitted by the built-in workflow scanner over ``.github/workflows/*.yml``.
+    Every issue is a positively-present misconfiguration (an unpinned action,
+    an untrusted-code checkout under ``pull_request_target``, a secret or an
+    attacker-controlled context interpolated into a shell step, ``write-all``
+    permissions, a self-hosted runner on a PR trigger) — a hardened workflow
+    produces nothing.
+    """
+
+    kind: Literal[
+        "unpinned_action",
+        "pr_target_checkout",
+        "secret_in_run",
+        "script_injection",
+        "broad_permissions",
+        "self_hosted_pr",
+    ]
+    file: str
+    line: int | None = None
+    # Human-readable location within the workflow (job / step) so evidence
+    # points somewhere actionable even when a precise line isn't available.
+    context: str | None = None
+    evidence_text: str | None = None
+    severity: Literal["low", "medium", "high"] = "medium"
+    source_analyzer: str | None = _PROVENANCE_FIELD
+
+
 class CryptoWeakness(BaseModel):
     """An insecure-cryptography or weak-randomness usage (#70).
 
@@ -279,6 +308,13 @@ class TaintChain(BaseModel):
     files: list[str] = Field(default_factory=list)
     evidence_text: str | None = None
     confidence: float = 0.6
+    # Sanitizer awareness (#137). When a known neutralizer for this sink kind
+    # is present in the sink file (escaper/validator/parameter-binder/
+    # allow-lister), the chain is marked sanitized and its confidence is
+    # downgraded — the tainted value is likely neutralized before the sink.
+    # `sanitizer_evidence` names the neutralizer so the chain stays auditable.
+    sanitized: bool = False
+    sanitizer_evidence: str | None = None
     source_analyzer: str | None = _PROVENANCE_FIELD
 
 
@@ -548,6 +584,7 @@ class ScanResult(BaseModel):
     crypto_weaknesses: list[CryptoWeakness] = Field(default_factory=list)
     web_hardening_issues: list[WebHardeningIssue] = Field(default_factory=list)
     code_weaknesses: list[CodeWeakness] = Field(default_factory=list)
+    workflow_issues: list[WorkflowIssue] = Field(default_factory=list)
     anomalies: list[Anomaly] = Field(default_factory=list)
     files_scanned: int = 0
 

{attackmap-0.4.5 → attackmap-0.4.10}/src/attackmap/report.py

@@ -15,6 +15,7 @@ from .exploitability import score_exploitability
 from .models import AttackPath, AttackSurface, ExploitabilityScore, Finding, ScanResult
 from .review_json import build_defensive_review_json
 from .sarif import build_sarif
+from .suppress import SuppressedFinding
 from .topology import build_service_graph
 
 
@@ -32,9 +33,11 @@ def write_reports(
     findings: list[Finding],
     attack_paths: list[AttackPath],
     analyzer_metadata: list[dict[str, object]] | None = None,
+    suppressed: list[SuppressedFinding] | None = None,
 ) -> None:
     out = Path(output_dir)
     out.mkdir(parents=True, exist_ok=True)
+    suppressed = suppressed or []
 
     (out / "architecture.md").write_text(architecture_md + "\n", encoding="utf-8")
     (out / "attack-surface.md").write_text(attack_surface_md + "\n", encoding="utf-8")
@@ -64,6 +67,18 @@ def write_reports(
         "findings": [
             {"id": finding_id(finding.title), **finding.model_dump()} for finding in findings
         ],
+        # Suppressed findings are retained (not dropped) with their reason so
+        # audits can see what was silenced and why (#144).
+        "suppressed_findings": [
+            {
+                "id": s.id,
+                "rule": s.rule,
+                "reason": s.reason,
+                "suppressed_by": [m.label() for m in s.matched],
+                **s.finding.model_dump(),
+            }
+            for s in suppressed
+        ],
         "attack_paths": [path.model_dump() for path in attack_paths],
         "exploitability": [score.model_dump() for score in exploitability],
     }
@@ -71,7 +86,11 @@ def write_reports(
 
     # SARIF 2.1.0 for GitHub Code Scanning / VS Code / other SARIF
     # consumers. Emitted alongside JSON, not in place of it.
-    sarif_report = build_sarif(findings, attack_paths)
+    sarif_report = build_sarif(
+        findings,
+        attack_paths,
+        suppressed=[(s.finding, s.reason) for s in suppressed],
+    )
     (out / "attackmap-report.sarif").write_text(
         json.dumps(sarif_report, indent=2) + "\n", encoding="utf-8"
     )