mcpprobe-scanner 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

mcpprobe/__init__.py

@@ -13,7 +13,7 @@ The package is organised as follows:
 
 from __future__ import annotations
 
-__version__ = "0.3.1"
+__version__ = "0.3.3"
 
 POLICY_URL = "https://mcpprobe.tech/scanning-policy"
 USER_AGENT = f"mcpprobe/{__version__} (+{POLICY_URL})"

mcpprobe/action.py

@@ -6,8 +6,8 @@ always writes SARIF, records outputs in ``$GITHUB_OUTPUT``, writes a job
 summary to ``$GITHUB_STEP_SUMMARY``, emits one workflow annotation that names
 the outcome, and exits with the scanner's exit code:
 
-- 0 clean (no finding at or above ``fail-on``)
-- 1 findings at or above ``fail-on``
+- 0 clean (no finding or attack chain at or above ``fail-on``)
+- 1 a finding or attack chain at or above ``fail-on``
 - 2 error (unreachable target, bad input, opt-out, authorisation refused)
 - 3 the target answered but is not an MCP server (wrong URL or path)
 
@@ -89,19 +89,49 @@ def sarif_counts(path: Path) -> dict[str, int]:
     return counts
 
 
-def describe(code: int, target: str, fail_on: str, counts: Mapping[str, int]) -> tuple[str, str, str]:
+def sarif_chain_counts(path: Path) -> dict[str, int]:
+    """Count attack chains (``runs[].properties.chains``) per severity; empty when unreadable.
+
+    Chains are not SARIF results: each one is built from findings that are already
+    results, so they are counted on their own.
+    """
+    counts = dict.fromkeys(_SEVERITIES, 0)
+    try:
+        data: Any = json.loads(path.read_text(encoding="utf-8"))
+        for run in data.get("runs", []):
+            for chain in run.get("properties", {}).get("chains", []):
+                sev = str(chain.get("severity", "info"))
+                counts[sev if sev in counts else "info"] += 1
+    except (OSError, ValueError, AttributeError):
+        return {}
+    return counts
+
+
+def describe(
+    code: int,
+    target: str,
+    fail_on: str,
+    counts: Mapping[str, int],
+    chain_counts: Mapping[str, int] | None = None,
+) -> tuple[str, str, str]:
     """Return (annotation level, title, message) for an exit code."""
     total = sum(counts.values())
     breakdown = ", ".join(f"{counts[s]} {s}" for s in _SEVERITIES if counts.get(s))
+    chain_counts = chain_counts or {}
+    chains = sum(chain_counts.values())
+    chain_breakdown = ", ".join(f"{chain_counts[s]} {s}" for s in _SEVERITIES if chain_counts.get(s))
+    chain_text = f" and {chains} attack chain(s) built from them ({chain_breakdown})" if chains else ""
     if code == EXIT_CLEAN:
-        found = f" ({breakdown} below the threshold)" if breakdown else ""
-        return "notice", "mcpprobe: passed", f"No finding at or above '{fail_on}' on {target}{found}."
+        below = ", ".join(x for x in (breakdown, f"attack chains: {chain_breakdown}" if chains else "") if x)
+        found = f" ({below} below the threshold)" if below else ""
+        what = "finding or attack chain" if chains else "finding"
+        return "notice", "mcpprobe: passed", f"No {what} at or above '{fail_on}' on {target}{found}."
     if code == EXIT_FINDINGS:
         return (
             "error",
             "mcpprobe: findings",
-            f"{total} finding(s) on {target} ({breakdown}); at least one is at or above '{fail_on}'. "
-            "See the job summary or the code scanning alerts.",
+            f"{total} finding(s) on {target} ({breakdown}){chain_text}; at least one is at or above "
+            f"'{fail_on}'. See the job summary or the code scanning alerts.",
         )
     if code == EXIT_NOT_MCP:
         return (
@@ -119,7 +149,14 @@ def describe(code: int, target: str, fail_on: str, counts: Mapping[str, int]) ->
     )
 
 
-def _summary(code: int, target: str, fail_on: str, counts: Mapping[str, int], message: str) -> str:
+def _summary(
+    code: int,
+    target: str,
+    fail_on: str,
+    counts: Mapping[str, int],
+    message: str,
+    chain_counts: Mapping[str, int] | None = None,
+) -> str:
     lines = [
         "## mcpprobe MCP security scan",
         "",
@@ -130,8 +167,13 @@ def _summary(code: int, target: str, fail_on: str, counts: Mapping[str, int], me
         "",
     ]
     if code in (EXIT_CLEAN, EXIT_FINDINGS) and counts:
-        lines += ["| Severity | Findings |", "|---|---|"]
-        lines += [f"| {s} | {counts[s]} |" for s in _SEVERITIES]
+        if chain_counts and sum(chain_counts.values()):
+            lines += ["| Severity | Findings | Attack chains |", "|---|---|---|"]
+            lines += [f"| {s} | {counts[s]} | {chain_counts.get(s, 0)} |" for s in _SEVERITIES]
+            lines += ["", "Each attack chain is built from findings counted in the Findings column."]
+        else:
+            lines += ["| Severity | Findings |", "|---|---|"]
+            lines += [f"| {s} | {counts[s]} |" for s in _SEVERITIES]
         lines.append("")
     lines.append(
         "Docs: https://mcpprobe.tech · checks: https://github.com/mcpprobe-dev/mcpprobe/blob/main/CHECKS.md"
@@ -157,7 +199,8 @@ def run(env: Mapping[str, str] | None = None) -> int:
     fail_on = argv[argv.index("--fail-on") + 1]
     sarif = argv[argv.index("--sarif") + 1]
     counts = sarif_counts(Path(sarif))
-    level, title, message = describe(code, target, fail_on, counts)
+    chain_counts = sarif_chain_counts(Path(sarif))
+    level, title, message = describe(code, target, fail_on, counts, chain_counts)
     print(f"::{level} title={_escape_property(title)}::{_escape(message)}", file=sys.stderr)
     out = env.get("GITHUB_OUTPUT")
     if out:
@@ -168,7 +211,7 @@ def run(env: Mapping[str, str] | None = None) -> int:
     summary = env.get("GITHUB_STEP_SUMMARY")
     if summary:
         with Path(summary).open("a", encoding="utf-8") as fh:
-            fh.write(_summary(code, target, fail_on, counts, message))
+            fh.write(_summary(code, target, fail_on, counts, message, chain_counts))
     return code
 
 

mcpprobe/checks/auth.py

@@ -401,7 +401,7 @@ class Auth03AuthorizationServerMetadata(Check):
                 "metadata is missing (AUTH-02).",
                 related_to="AUTH-02",
             )
-        servers = [s for s in prm.get("authorization_servers") or [] if isinstance(s, str)]
+        servers = list(dict.fromkeys(s for s in prm.get("authorization_servers") or [] if isinstance(s, str)))
         if not servers:
             raise NotApplicable(
                 "The protected resource metadata lists no authorization server (AUTH-02).",
@@ -501,6 +501,7 @@ class Auth03AuthorizationServerMetadata(Check):
                         confidence=Confidence.HIGH,
                         evidence=evidence_of(*responses),
                         location=issuer,
+                        variant="plain-http-endpoints",
                         details={"insecure_endpoints": insecure},
                         affected=insecure,
                         proof=doc_proof,
@@ -511,6 +512,7 @@ class Auth03AuthorizationServerMetadata(Check):
                 findings.append(
                     self.finding(
                         title="Authorization server issuer mismatch",
+                        variant="issuer-mismatch",
                         description=f"Metadata issuer {doc['issuer']!r} differs from advertised {issuer!r}.",
                         severity=Severity.LOW,
                         confidence=Confidence.MEDIUM,
@@ -625,6 +627,8 @@ class Auth04TokenAudienceAndPassthrough(Check):
                         else "The response was 2xx but carried no JSON-RPC result, so acceptance is inferred from the status only.",
                         evidence=evidence_of(resp),
                         location=ctx.target,
+                        # Both self-minted tokens can be accepted; the second needs its own uid.
+                        variant=None if label == "HS256/random-key" else "alg-none",
                         details={"probe": label, "claims": now_claims},
                         affected=[label],
                         proof=proof.exchange(

mcpprobe/checks/base.py

@@ -186,6 +186,7 @@ class Check(abc.ABC):
         confidence: Confidence = Confidence.HIGH,
         evidence: list[EvidenceRecord] | None = None,
         location: str | None = None,
+        variant: str | None = None,
         fix: str | None = None,
         details: dict[str, Any] | None = None,
         title: str | None = None,
@@ -198,7 +199,9 @@ class Check(abc.ABC):
         """Build a :class:`Finding` pre-filled from the check's metadata.
 
         ``excerpt`` overrides the evidence excerpt that is otherwise derived from
-        the first evidence record. A finding whose confidence is not high must
+        the first evidence record. ``variant`` must be set on every finding after
+        the first that the check can report at the same ``location`` in one scan,
+        so each finding keeps a distinct, stable ``uid``. A finding whose confidence is not high must
         say why (``confidence_reason``); this is enforced so no label goes unexplained.
         """
         records = [e for e in (evidence or []) if e is not None]
@@ -215,6 +218,7 @@ class Check(abc.ABC):
             evidence=records,
             evidence_excerpt=excerpt if excerpt is not None else evidence_excerpt(records),
             location=location,
+            variant=variant,
             details=details or {},
             false_positive_notes=self.false_positive_notes or None,
             confidence_reason=confidence_reason,

mcpprobe/checks/baseline.py

@@ -204,6 +204,7 @@ class Meta02RugPullBaseline(Check):
             out.append(
                 self.finding(
                     title="Tools removed since baseline",
+                    variant="removed",
                     description="Removed tools: " + ", ".join(tools["removed"]) + ".",
                     severity=Severity.INFO,
                     confidence=Confidence.HIGH,

mcpprobe/checks/metadata.py

@@ -206,6 +206,7 @@ class Meta03DangerousCapabilitySurface(Check):
             findings.append(
                 self.finding(
                     title="High-impact tool capabilities exposed",
+                    variant="high-impact",
                     description="Tools classified as high-impact: "
                     + summary
                     + ". Review that each is necessary, scoped and gated by user approval.",
@@ -354,6 +355,7 @@ class Meta04SchemaHygiene(Check):
             findings.append(
                 self.finding(
                     title="Duplicate tool names",
+                    variant="duplicate-names",
                     description="Tool names listed more than once: " + ", ".join(dupes) + ".",
                     severity=Severity.MEDIUM,
                     confidence=Confidence.HIGH,

mcpprobe/checks/robustness.py

@@ -165,6 +165,7 @@ class Err01VerboseErrors(Check):
             findings.append(
                 self.finding(
                     title="Server header discloses software version",
+                    variant="server-header",
                     description=f"Server: {server_header}",
                     severity=Severity.INFO,
                     confidence=Confidence.HIGH,
@@ -281,6 +282,7 @@ class Dos01UnboundedConsumption(Check):
                 findings.append(
                     self.finding(
                         title=f"Server struggled with {label} request",
+                        variant=f"{label}-probe",
                         description=f"The {label} probe produced: {problem}. Input limits may be missing.",
                         severity=Severity.LOW if "slow" in problem else Severity.MEDIUM,
                         confidence=Confidence.MEDIUM,

mcpprobe/checks/transport_conformance.py

@@ -360,6 +360,7 @@ class Trans03SessionIdQuality(Check):
             findings.append(
                 self.finding(
                     title="Forged session ID accepted",
+                    variant="forged-session-id",
                     description=(
                         "tools/list with a random, never-issued Mcp-Session-Id was answered with a "
                         "result. The server does not validate session IDs (spec: 404 for unknown sessions)."
@@ -461,6 +462,7 @@ class Trans04DeprecatedTransport(Check):
             findings.append(
                 self.finding(
                     title="Pre-2025-06-18 protocol revision negotiated",
+                    variant="old-revision",
                     description=f"The server negotiated protocol revision {fp.protocol_version}, "
                     "which predates the current authorization and transport requirements.",
                     severity=Severity.INFO,
@@ -521,6 +523,7 @@ class Trans05TlsAndHeaders(Check):
             findings.append(
                 self.finding(
                     title="MCP endpoint served over plain HTTP",
+                    variant="plain-http",
                     description=(
                         "The endpoint is reachable over unencrypted HTTP; bearer tokens, session IDs "
                         "and tool data travel in the clear."
@@ -546,6 +549,7 @@ class Trans05TlsAndHeaders(Check):
             findings.append(
                 self.finding(
                     title="Weak TLS version negotiated",
+                    variant="weak-tls",
                     description=f"The connection negotiated {http.tls_version}.",
                     severity=Severity.MEDIUM,
                     confidence=Confidence.HIGH,

mcpprobe/cli.py

@@ -2,8 +2,8 @@
 
 ``mcpprobe <target>`` is shorthand for ``mcpprobe scan <target>``.
 
-Exit codes: 0 = no findings at or above ``--fail-on``; 1 = findings at or
-above ``--fail-on``; 2 = error (unreachable target, opt-out, authorisation
+Exit codes: 0 = no finding or attack chain at or above ``--fail-on``; 1 = a
+finding or attack chain at or above ``--fail-on``; 2 = error (unreachable target, opt-out, authorisation
 refused, bad arguments).
 """
 
@@ -112,7 +112,7 @@ def _parse_kv(values: Sequence[str], what: str, sep: str) -> dict[str, str]:
     default="high",
     type=click.Choice(SEVERITIES),
     show_default=True,
-    help="Exit 1 if any finding is at or above this severity.",
+    help="Exit 1 if any finding or attack chain is at or above this severity.",
 )
 @click.option(
     "--json", "json_path", type=click.Path(dir_okay=False), help="Write the JSON report (with evidence) here."

mcpprobe/models.py

@@ -7,10 +7,12 @@ report is a faithful, schema-stable serialisation of what the scanner saw.
 from __future__ import annotations
 
 import datetime as dt
+import hashlib
+import json
 from enum import Enum
 from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, computed_field
 
 #: Maximum number of body bytes retained per request/response in evidence.
 #: Proof excerpts are always built from parsed data, never from this copy.
@@ -145,6 +147,13 @@ class Finding(BaseModel):
         default=None,
         description="Where in the target the issue lives (tool name, header, URL path...)",
     )
+    variant: str | None = Field(
+        default=None,
+        description=(
+            "Distinguishes separate findings of one check at the same location "
+            "(e.g. 'forged-session-id'); None for the check's main finding"
+        ),
+    )
     details: dict[str, Any] = Field(default_factory=dict)
     false_positive_notes: str | None = None
     confidence_reason: str | None = Field(
@@ -162,10 +171,82 @@ class Finding(BaseModel):
         default_factory=list, description="IDs of the supporting evidence records"
     )
 
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def uid(self) -> str:
+        """Identity of this finding, unique within a report and stable across scans.
+
+        ``<check id>:<location or ->``, plus ``:<variant>`` when the check reports more
+        than one thing at the same location. ``id`` stays the check ID (several findings
+        can share it); ``uid`` is what tells them apart.
+        """
+        base = f"{self.id}:{self.location or '-'}"
+        return f"{base}:{self.variant}" if self.variant else base
+
     @property
     def fingerprint(self) -> str:
-        """Stable identity for de-duplication across scans (used in SARIF)."""
-        return f"{self.id}:{self.location or '-'}"
+        """Stable identity for de-duplication across scans (SARIF ``partialFingerprints``)."""
+        return self.uid
+
+    def content_digest(self) -> str:
+        """Hash of what the finding says (not of its evidence), used to spot genuine duplicates."""
+        payload = json.dumps(
+            [
+                self.id,
+                self.location,
+                self.variant,
+                self.title,
+                self.severity.value,
+                self.description,
+                sorted(self.affected),
+                self.details,
+            ],
+            sort_keys=True,
+            default=str,
+            ensure_ascii=False,
+        )
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def dedupe_findings(findings: list[Finding]) -> list[Finding]:
+    """Return ``findings`` with genuine duplicates merged and every ``uid`` unique.
+
+    Two findings with the same ``uid`` that say the same thing (same title, severity,
+    description, affected items and details) are one finding reported twice, for
+    example because the server listed the same tool twice; they are merged into the
+    first, keeping the union of their evidence. Findings that share a ``uid`` but say
+    different things are kept, and each gets a variant derived from its content (not
+    from its position), so the ``uid`` stays the same from one scan to the next.
+    Order is preserved.
+    """
+    by_uid: dict[str, list[Finding]] = {}
+    for f in findings:
+        by_uid.setdefault(f.uid, []).append(f)
+    if all(len(group) == 1 for group in by_uid.values()):
+        return list(findings)
+    keep: dict[int, Finding] = {}
+    for group in by_uid.values():
+        merged: dict[str, Finding] = {}
+        for f in group:
+            digest = f.content_digest()
+            first = merged.get(digest)
+            if first is None:
+                merged[digest] = f
+                keep[id(f)] = f
+            else:
+                _merge_into(first, f)
+        if len(merged) > 1:
+            for digest, f in merged.items():
+                f.variant = f"{f.variant}-{digest[:8]}" if f.variant else digest[:8]
+    return [f for f in findings if id(f) in keep]
+
+
+def _merge_into(target: Finding, dup: Finding) -> None:
+    seen = {e.id for e in target.evidence}
+    target.evidence.extend(e for e in dup.evidence if e.id not in seen)
+    for eid in dup.evidence_ids:
+        if eid not in target.evidence_ids:
+            target.evidence_ids.append(eid)
 
 
 class CheckStatus(str, Enum):
@@ -346,12 +427,23 @@ class ScanReport(BaseModel):
     notes: list[str] = Field(default_factory=list)
 
     def counts(self) -> dict[str, int]:
-        """Number of findings per severity (all five keys always present)."""
+        """Number of findings per severity (all five keys always present).
+
+        Attack chains are not findings: each one is built from findings already
+        counted here, so they are counted separately by :meth:`chain_counts`.
+        """
         out = {s.value: 0 for s in _SEVERITY_ORDER}
         for f in self.findings:
             out[f.severity.value] += 1
         return out
 
+    def chain_counts(self) -> dict[str, int]:
+        """Number of attack chains per severity (all five keys always present)."""
+        out = {s.value: 0 for s in _SEVERITY_ORDER}
+        for c in self.chains:
+            out[c.severity.value] += 1
+        return out
+
     def coverage(self) -> dict[str, int]:
         """Check outcomes. ``passed`` counts only checks that ran and found nothing."""
         out = {
@@ -370,7 +462,18 @@ class ScanReport(BaseModel):
         return out
 
     def max_severity(self) -> Severity | None:
-        """Highest severity present, or ``None`` when there are no findings."""
+        """Highest severity of any finding or attack chain, or ``None`` when there is neither.
+
+        A chain can be rated above every finding it is built from (CHAIN-01 is critical
+        while AUTH-01 and META-03 are high), so it takes part in the pass/fail decision.
+        """
+        sevs = [f.severity for f in self.findings] + [c.severity for c in self.chains]
+        if not sevs:
+            return None
+        return max(sevs, key=lambda s: s.rank)
+
+    def findings_max_severity(self) -> Severity | None:
+        """Highest severity among findings only, or ``None`` when there are no findings."""
         if not self.findings:
             return None
         return max((f.severity for f in self.findings), key=lambda s: s.rank)

mcpprobe/registry/select.py

@@ -89,7 +89,12 @@ def select_targets(
     *,
     max_urls_per_host: int = 1,
 ) -> Selection:
-    """One target per host (streamable-http preferred over SSE); every decision counted."""
+    """One target per host (streamable-http preferred over SSE); every decision counted.
+
+    Every remote URL ends up either selected or under exactly one reason in ``excluded``, so
+    ``remote_urls - sum(excluded) == selected_urls``, and with ``max_urls_per_host=1``
+    ``selected_urls == unique_hosts``.
+    """
     exclusions = exclusions or Exclusions()
     sel = Selection()
     by_host: dict[str, dict[str, Any]] = {}
@@ -130,6 +135,9 @@ def select_targets(
             if entry["name"] not in target["entries"]:
                 target["entries"].append(entry["name"])
             if url in target["urls"]:
+                # The same URL listed again (another entry, version or transport): count it,
+                # or the funnel would not add up (remote_urls - excluded != selected URLs).
+                sel.excluded["duplicate_url"] += 1
                 continue
             if len(target["urls"]) >= max_urls_per_host:
                 sel.excluded["duplicate_host"] += 1
@@ -146,6 +154,7 @@ def select_targets(
         "no_remote_no_package_entries": kinds["no_remote_no_package"],
         "remote_urls": remote_urls,
         "excluded": dict(sorted(sel.excluded.items())),
+        "selected_urls": sum(len(t["urls"]) for t in sel.targets),
         "unique_hosts": len(sel.targets),
         "rate_keys": len({t["rate_key"] for t in sel.targets}),
         "max_urls_per_host": max_urls_per_host,

mcpprobe/report/json_report.py

@@ -13,10 +13,15 @@ from mcpprobe.transport import EvidenceLog
 def report_to_dict(report: ScanReport, evidence: EvidenceLog | None = None) -> dict[str, Any]:
     data: dict[str, Any] = report.model_dump(mode="json")
     worst = report.max_severity()
+    worst_finding = report.findings_max_severity()
     coverage = report.coverage()
     data["summary"] = {
+        # Findings only; chains are built from these findings and are counted separately.
         "counts": report.counts(),
+        "chain_counts": report.chain_counts(),
+        # Worst of findings and attack chains: the value the exit code is decided on.
         "max_severity": worst.value if worst is not None else None,
+        "findings_max_severity": worst_finding.value if worst_finding is not None else None,
         "target_kind": report.target_kind,
         # "passed" = ran and found nothing; not_applicable never counts as passed.
         "checks_passed": coverage["passed"],

mcpprobe/report/sarif.py

@@ -194,6 +194,7 @@ def to_sarif(report: ScanReport, *, location_uri: str | None = None) -> dict[str
                 "mode": report.mode.value,
                 "fingerprint": report.fingerprint.model_dump(mode="json") if report.fingerprint else None,
                 "counts": report.counts(),
+                "chainCounts": report.chain_counts(),
                 "targetKind": report.target_kind,
                 # Only checks that ran and found nothing are passes; not_applicable is not a pass.
                 "coverage": report.coverage(),

mcpprobe/report/terminal.py

@@ -93,6 +93,49 @@ def _finding_block(f: Finding, verbose: bool) -> Group:
     return Group(*lines)
 
 
+def _count_line(label: str, counts: dict[str, int], tail: str) -> Text:
+    line = Text(label)
+    for sev in _ORDER:
+        style = severity_style(sev, badge=True) if counts[sev.value] else "dim"
+        line.append(f" {sev.value} {counts[sev.value]} ", style=style)
+        line.append(" ")
+    line.append(tail, style="dim")
+    return line
+
+
+def summary_lines(report: ScanReport) -> list[Text]:
+    """The per-severity count lines: findings, then attack chains when there are any.
+
+    Chains are counted on their own line because each one is built from findings that
+    are already counted; adding them to the findings counts would count those twice.
+    """
+    counts = report.counts()
+    total = sum(counts.values())
+    if not report.chains:
+        return [_count_line("Findings ", counts, f"({total} {'finding' if total == 1 else 'findings'})")]
+    chain_counts = report.chain_counts()
+    n = sum(chain_counts.values())
+    return [
+        _count_line("Findings      ", counts, f"({total} {'finding' if total == 1 else 'findings'})"),
+        _count_line(
+            "Attack chains ",
+            chain_counts,
+            f"({n} {'chain' if n == 1 else 'chains'}, built from the findings counted above)",
+        ),
+    ]
+
+
+def fail_reason(report: ScanReport, fail_on: Severity) -> str:
+    """Why the result is FAIL: findings, attack chains, or both, at or above ``fail_on``."""
+    findings = any(f.severity >= fail_on for f in report.findings)
+    chains = any(c.severity >= fail_on for c in report.chains)
+    if findings and chains:
+        return f"findings and attack chains at or above {fail_on.value}"
+    if chains:
+        return f"attack chain at or above {fail_on.value}"
+    return f"findings at or above {fail_on.value}"
+
+
 def render(
     report: ScanReport,
     console: Console | None = None,
@@ -136,13 +179,8 @@ def render(
         console.print(Text("No check was run against this target; nothing passed.", style="dim"))
         return
 
-    counts = report.counts()
-    summary = Text("Findings ")
-    for sev in _ORDER:
-        style = severity_style(sev, badge=True) if counts[sev.value] else "dim"
-        summary.append(f" {sev.value} {counts[sev.value]} ", style=style)
-        summary.append(" ")
-    console.print(summary)
+    for line in summary_lines(report):
+        console.print(line)
     console.print()
 
     for chain in report.chains:
@@ -212,9 +250,7 @@ def render(
     if fail_on is not None:
         top = report.max_severity()
         if top is not None and top >= fail_on:
-            console.print(
-                Text(f"Result: FAIL (findings at or above {fail_on.value})", style=severity_style(top))
-            )
+            console.print(Text(f"Result: FAIL ({fail_reason(report, fail_on)})", style=severity_style(top)))
         else:
             console.print(
                 Text(f"Result: PASS (nothing at or above {fail_on.value})", style=f"bold {PASS_HEX}")

mcpprobe/scanner.py

@@ -22,6 +22,7 @@ from mcpprobe.models import (
     Fingerprint,
     Inventory,
     ScanReport,
+    dedupe_findings,
     utcnow,
 )
 from mcpprobe.policy import DEFAULT_RATE, check_opt_out, clamp_rate
@@ -247,7 +248,7 @@ async def run_check(check: Check, ctx: ScanContext) -> CheckResult:
     started = time.monotonic()
     throttled_before = ctx.transport.throttle_exhausted
     try:
-        result.findings = await check.run(ctx)
+        result.findings = dedupe_findings(await check.run(ctx))
     except NotApplicable as exc:
         result.status = CheckStatus.NOT_APPLICABLE
         result.reason = exc.reason
@@ -372,9 +373,12 @@ async def run_scan(config: ScanConfig) -> tuple[ScanReport, EvidenceLog]:
             report.checks.append(result)
             report.findings.extend(result.findings)
         report.notes.extend(ctx.notes)
+        # Each check's findings are already de-duplicated; this keeps the report-wide
+        # list (and so counts, max severity, chains and SARIF results) to one entry per uid.
+        report.findings = dedupe_findings(report.findings)
         report.chains = build_chains(report, ctx)
         report.readiness = build_readiness(report)
     report.finished_at = utcnow()
     report.evidence_count = len(evidence)
-    report.findings.sort(key=lambda f: (-f.severity.rank, f.id, f.location or ""))
+    report.findings.sort(key=lambda f: (-f.severity.rank, f.id, f.location or "", f.variant or ""))
     return report, evidence

{mcpprobe_scanner-0.3.1.dist-info → mcpprobe_scanner-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpprobe-scanner
-Version: 0.3.1
+Version: 0.3.3
 Summary: Security scanner for Model Context Protocol (MCP) servers: auth, transport, tool-metadata and poisoning checks with JSON and SARIF output.
 Project-URL: Homepage, https://mcpprobe.tech
 Project-URL: Scanning policy, https://mcpprobe.tech/scanning-policy
@@ -182,8 +182,8 @@ process are in [docs/registry-report.md](docs/registry-report.md).
 
 | Code | Meaning |
 |---|---|
-| `0` | No finding at or above `--fail-on` (default `high`) |
-| `1` | At least one finding at or above `--fail-on` |
+| `0` | No finding or attack chain at or above `--fail-on` (default `high`) |
+| `1` | At least one finding or attack chain at or above `--fail-on` |
 | `2` | Error: target unreachable, bad arguments, ownership verification failed, authorisation refused, or the target opted out |
 | `3` | The target answered but is not an MCP server (for example an ordinary web site); every check is reported not applicable and nothing passes |
 
@@ -202,7 +202,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: mcpprobe-dev/mcpprobe@v0.3.1
+      - uses: mcpprobe-dev/mcpprobe@v0.3.3
         id: scan
         with:
           target: https://staging.your-server.example/mcp

{mcpprobe_scanner-0.3.1.dist-info → mcpprobe_scanner-0.3.3.dist-info}/RECORD

@@ -1,32 +1,32 @@
-mcpprobe/__init__.py,sha256=WBsl9QPqoSNwYOkW1tf700ZdIPK6zf3kIopirTHV3Ec,821
-mcpprobe/action.py,sha256=m9gVgSJABw_WABAAl4hgV4QOyJaOOArhPL3H1GIr8x4,6959
+mcpprobe/__init__.py,sha256=PNej_6ygJx84uJpIgm_HjldTy3UMcNcwp32ImaxuOmE,821
+mcpprobe/action.py,sha256=oHsoM82lKf9eBNjKvP9YM-ec0H_floAUxS5JKk8S1sQ,8760
 mcpprobe/authz.py,sha256=PCql53OFLQsN7oZxm2UtoAqTmT7LWRRw5nmx_50ePik,10595
 mcpprobe/catalogue.py,sha256=j0h-O-2FQq158P97bXf3akD0S3gzxt7P4AUJYMHbYss,4729
 mcpprobe/chains.py,sha256=BgFu82WduTme1MiSFtBkwWpTHbfFBBteCLV_yBB8nWA,4227
-mcpprobe/cli.py,sha256=AcYELaCNJo94vb6CdsbwD3q_iBGjZXq12D11nfOiey4,12823
+mcpprobe/cli.py,sha256=tC6nFYHrjxljqvv5BOc6vJfKDgdca8r7OwoQiEeAl1I,12871
 mcpprobe/dnsutil.py,sha256=d9AWtU96SHE7QzphZk76L9r61LpI0MuxPYLHEijHK4Y,1958
 mcpprobe/environment.py,sha256=9wbVmoJFXwGnqL4LHvt0D6dZupX650MjAgjq675xsyk,1937
 mcpprobe/governance.py,sha256=khs0t3jjSbwYzFYAjywnOzy_9m_qXy4ctuaFJy8UkdI,3391
-mcpprobe/models.py,sha256=7TyVUbKJSypS6FJHY7g9N5xptGg8x0Kl8vbrSPp6rRI,13381
+mcpprobe/models.py,sha256=ALrCGIVYoMuvI373M86-McojPu4ZcXVAIGOew8pk_4I,17540
 mcpprobe/policy.py,sha256=VWb6R3Udetp3AFk-BJqulRJREquyvtvP1VS8QhUOMdo,4865
 mcpprobe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcpprobe/readiness.py,sha256=DzI09yU0PmcGmn8jZhfvVPgRu3VDkP6GxKLbtE0qviY,13234
 mcpprobe/redact.py,sha256=8VhTwssMnU2cKKL2dm2omLfjpxDWtX1GJTS8f_iWcTM,3775
-mcpprobe/scanner.py,sha256=CHXVDijzpjgAyhxQYo6msIrLxVvCwgt9Ybveg-TNNkw,15561
+mcpprobe/scanner.py,sha256=ERgUL1JUW36q1toagFBAbVqO-TFTZrHAVXpjnD192kM,15854
 mcpprobe/checks/__init__.py,sha256=GR0Hu_enDizBqZYdZZhYVytHSxfMCkliqPABNV2aBz0,3459
 mcpprobe/checks/_util.py,sha256=5_8aLzoU3yfqWz6HcaHweb_j9KxuO0WgRDBiox39GIQ,3125
 mcpprobe/checks/active_stubs.py,sha256=zI-0sw2ncmg6B2tiia0laJOPcfzMFWfagY0G6wfPMfY,9129
-mcpprobe/checks/auth.py,sha256=-RaD21lILpHyv2wbw4G7RNin3u2NqQskmmh8ScS68uQ,35638
-mcpprobe/checks/base.py,sha256=iw3hAdCE-n7In6GQTtoCFWMMnORo6vA6ncz5z1kMwWc,10872
-mcpprobe/checks/baseline.py,sha256=Wm4rsxFg8ZLy_pFD1IiN02lt1pbLTyVFtnZWMftpyOU,11475
+mcpprobe/checks/auth.py,sha256=io9T2smWBCHSzTjRMr6TNmnLl7hlUaqf1D2RmLxKT6Q,35946
+mcpprobe/checks/base.py,sha256=GjMGJbXSNXibZUkv8k0E3CBfvpHaAwjVOp18O96HK1o,11124
+mcpprobe/checks/baseline.py,sha256=cyNDmCYBgxLnA3Z3IloY4sA369965qMNqWlnv5ZBO_M,11514
 mcpprobe/checks/capability.py,sha256=3-BQolVRCEnz1ik27I07-05J5Pb2dcojg3DfD4H1k7M,13506
-mcpprobe/checks/metadata.py,sha256=oXRwnE0itYMpkW0gzCELPCjG9RPVd4e0NMtuhvXDQsU,25870
+mcpprobe/checks/metadata.py,sha256=I83VA_RH_UNxMIjmSq8WxbuH5JLho0IzsLjYLyhqW_o,25960
 mcpprobe/checks/poisoning.py,sha256=oaZrKG_QJWBr0dtOiKsxD2OdkbeMNwuuavNaLc7MJ5g,31915
 mcpprobe/checks/proof.py,sha256=0h4uDF5AvKpkEWRAVtNk9I0Ei5fUugeqRqiNf3Ln1aA,6091
 mcpprobe/checks/protocol_2026.py,sha256=PEWu61h8s718WQf62O6rEii_qTLeP60tC2lA0TiAU5M,35456
-mcpprobe/checks/robustness.py,sha256=mMIl43tP-d-WkJmIJ501qHOLiwCC-IVjzjPNNDGS164,18215
+mcpprobe/checks/robustness.py,sha256=TLL03Dp6wAYRfCvpK5dPahWU1YSX_Vx6M7vQeCR55pM,18310
 mcpprobe/checks/tool_surface.py,sha256=nbHiaM-LoDoK5y0hCo2mMeZUHR2UegXfUtjvjd4zjzQ,16660
-mcpprobe/checks/transport_conformance.py,sha256=rZ0pHC2KsNoyZaJSaDnSeu4vS3qk7evWRtFl4q4tWvY,30703
+mcpprobe/checks/transport_conformance.py,sha256=kjNR8-S7n273ESjE3p1SJmaG09glnMtvMzKxOfI0bpI,30878
 mcpprobe/judges/__init__.py,sha256=W-rRq00lnOEiVIH27pAmLK52AVIRSUhRxth3dlZw_Ws,1372
 mcpprobe/judges/hf.py,sha256=lQaMq5qwrdIzivcnrdmMd9sTtHOSNEtoAxguDoMhLMI,5412
 mcpprobe/registry/__init__.py,sha256=Ou7Fy9kZUQgWYKCudnzXPit3Hi5_-RMNham3M_YhJok,1405
@@ -38,13 +38,13 @@ mcpprobe/registry/common.py,sha256=q-d8W0SMvLopGB6JCmAwlYYckF4p1NUN_42JreuLp2c,9
 mcpprobe/registry/fetch.py,sha256=xsj6nwNHw7adhMS-Z-BFjqNmw06pGofLJEZnFmvQjoM,10701
 mcpprobe/registry/pipeline.py,sha256=b3j1Ww3Krwn4EwZTL4h1z8Zf_3Q8XapFSPZfM3qWv4M,17885
 mcpprobe/registry/render.py,sha256=gvDyeXUbOFUaeUw5Nub4QABNgKQUZf9Ih1RDINHUE_g,15447
-mcpprobe/registry/select.py,sha256=UtdWT0kWMyKsB9Fx397MqUkwbGmnLjMujirpuE65NCk,5811
+mcpprobe/registry/select.py,sha256=QW3d5ILDC7VhLSzH2g0NAtzK2OE34TD8_aNN1dvE3Ok,6339
 mcpprobe/registry/static.py,sha256=Lg3akNSRaxrqd0dgeasEvsTmVVPVlHuc4EcaTvI4mKc,4400
 mcpprobe/registry/template.py,sha256=oR4Fn1T2XA6Kf87fpzRutbP_2H9bjMKG_qYqBOV78Jc,7081
 mcpprobe/report/__init__.py,sha256=n1Q29xF32h-8_VKiOHkvEl7uMf2VdKXyeDc9FLVO8u0,318
-mcpprobe/report/json_report.py,sha256=FgYLa2M1XiRvrWTzq201ZBpwbC8ciJkUUzMCyXhNgjI,1763
-mcpprobe/report/sarif.py,sha256=iMdDZjq4KaG6A4m1HdA4WzdajjwFslguc5bZpoDkieM,14458
-mcpprobe/report/terminal.py,sha256=Pp2iQKUFrAC19lpWJoinhobk1I7U4WxNCCHxB7enNXg,8677
+mcpprobe/report/json_report.py,sha256=Y5_tq3YktH9ghMMyf3DjCoalk_mYGiHfDMefyf-6tKU,2130
+mcpprobe/report/sarif.py,sha256=MYx6VhSQa-3ujnHXj6ljm2pPgsvZSrwm8DGAbmPFWHQ,14512
+mcpprobe/report/terminal.py,sha256=244NtWlr0bUHKJdScomtyqVRXie-3V8xqeSz61S9BTw,10172
 mcpprobe/transport/__init__.py,sha256=ZmUxTFl9Vm0MWy67Gb3BWM7LwL3ki1ZZ_8r54mK9f3U,863
 mcpprobe/transport/base.py,sha256=toXv95G127UPLODwxeAEQlSkPRU1pioL3Fktg1ZZhbU,6739
 mcpprobe/transport/evidence.py,sha256=NWk11U6Kzwc0ElLvSLezxcbFtizGrDXgDBKvstzDlRE,4156
@@ -52,9 +52,9 @@ mcpprobe/transport/fingerprint.py,sha256=NdJ0AyQWMPzzLA0T4bRdmdgPocHdJyBPE6Pin0q
 mcpprobe/transport/http.py,sha256=apclGNB6eeIqrvk1KreweA2g6WAo3vq7jpFCpUq-LlQ,17624
 mcpprobe/transport/ratelimit.py,sha256=g6mLxbVyXVVk0ndJ2jwJuC_RqfojbyHlABUTL7ys_9w,1578
 mcpprobe/transport/stdio.py,sha256=b_7cLDTidW5HVK_p7mT1fz0uYAdA7hh5ZlmFG65EBf4,7559
-mcpprobe_scanner-0.3.1.dist-info/METADATA,sha256=HUAqMNKaAnC1ncVVc5lSPr3D0YGf_-8rhTF5zRdS_0w,14252
-mcpprobe_scanner-0.3.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-mcpprobe_scanner-0.3.1.dist-info/entry_points.txt,sha256=NEMxBH370sFz_Vw8812R7adD_DDQ3ZI7ixcuWZNQCHY,47
-mcpprobe_scanner-0.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mcpprobe_scanner-0.3.1.dist-info/licenses/NOTICE,sha256=WJJBETgUGNWnB0pvAWlb0Jx42dRffM3WAtKuabvNF2o,406
-mcpprobe_scanner-0.3.1.dist-info/RECORD,,
+mcpprobe_scanner-0.3.3.dist-info/METADATA,sha256=iEqFaZ8EqmSS9M9MZv8tUJtqUPIm9Hoko3fLZDndTzE,14284
+mcpprobe_scanner-0.3.3.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+mcpprobe_scanner-0.3.3.dist-info/entry_points.txt,sha256=NEMxBH370sFz_Vw8812R7adD_DDQ3ZI7ixcuWZNQCHY,47
+mcpprobe_scanner-0.3.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mcpprobe_scanner-0.3.3.dist-info/licenses/NOTICE,sha256=WJJBETgUGNWnB0pvAWlb0Jx42dRffM3WAtKuabvNF2o,406
+mcpprobe_scanner-0.3.3.dist-info/RECORD,,