Open-source AI penetration testing tool to find and fix your app’s vulnerabilities.
Python agentsai-hackingai-penetration-testingai-pentestingai-securityartificial-intelligencebug-bountycode-qualityctf-toolscybersecuritycybersecurity-toolsethical-hackinghackingllm-securityoffensive-securitypenetration-testingpentesting-toolsred-teamingsecuritysecurity-automation
Contextual CVSS as a full 8-metric breakdown, computed like a normal finding
Ahmed Allame442db9c93aa
diff --git a/strix/report/writer.py b/strix/report/writer.pyindex 794a23a5..2cdbae22 100644--- a/strix/report/writer.py+++ b/strix/report/writer.py@@ -215,14 +215,11 @@ def render_vulnerability_md(report: dict[str, Any]) -> str: # noqa: PLR0912, PLcvss = report.get("cvss")if cvss is not None:metadata.append(("CVSS", cvss))- contextual_metrics = dep_meta.get("contextual_cvss_metrics")- if isinstance(contextual_metrics, dict) and contextual_metrics:- metadata.append(- (- "Contextual CVSS Metrics",- "/".join(f"{metric}:{value}" for metric, value in contextual_metrics.items()),- )- )+ advisory_cvss = dep_meta.get("advisory_cvss")+ if advisory_cvss is not None and advisory_cvss != cvss:+ metadata.append(("Advisory CVSS", advisory_cvss))+ if dep_meta.get("contextual_cvss_vector"):+ metadata.append(("Contextual CVSS Vector", dep_meta["contextual_cvss_vector"]))if report.get("fix_effort"):metadata.append(("Fix Effort", str(report["fix_effort"]).title()))for label, value in metadata:diff --git a/strix/skills/custom/dependency_cve_scanning.md b/strix/skills/custom/dependency_cve_scanning.mdindex 5f4d09a2..e5afd3de 100644--- a/strix/skills/custom/dependency_cve_scanning.md+++ b/strix/skills/custom/dependency_cve_scanning.md@@ -241,63 +241,68 @@ findings and rejects empty PoC fields):installed/affected version, fixed version, lockfile path, and the relevanttrivy output excerpt.- **Always set `advisory_cvss` to the published advisory base score (0.0–10.0).**- Severity is derived *solely* from this number: read it off the advisory (`CVSS`- in trivy output, or the NVD/GHSA page) and pass the real value. The tool rejects- a call that omits it, because guessing a score both inflates low CVEs and- deflates critical ones.+ It is the published reference, and it rates the finding whenever you give no+ contextual breakdown: read it off the advisory (`CVSS` in trivy output, or the+ NVD/GHSA page) and pass the real value. The tool rejects a call that omits it,+ because guessing a score both inflates low CVEs and deflates critical ones.- Set `cwe` to the most specific `CWE-NNN` when the advisory names one.- Do NOT cap severity at LOW just because there is no dynamic reproduction — usethe advisory score.- Set `reachability` + `reachability_evidence` from the usage analysis above;use `assumptions` for anything softer (confidence, caveats, analysis limits).-- Set `contextual_cvss_metrics` + `contextual_cvss_reasoning` when this codebase- clearly changes the risk the published score describes (see below).--### Contextual (environmental) CVSS--The published score rates the CVE in the abstract. `contextual_cvss_metrics`-rates it **here**, in this codebase, with CVSS v3.1 environmental metrics. The-advisory's base metrics stay fixed — you never restate them and never pass a-score, the adjusted score is computed from the resulting vector.--Set only what your usage analysis supports:--- `MAV` `N`/`A`/`L`/`P` — the attack vector as deployed. A library reached only- by a local CLI is `L`, not `N`.-- `MAC` `L`/`H` — raise to `H` when the vulnerable path needs a precondition the- code enforces (input validation, a non-default flag, an internal-only route).-- `MPR` `N`/`L`/`H`, `MUI` `N`/`R` — privileges or interaction this deployment- requires before the path is reachable.-- `MS` `U`/`C` — whether exploitation here escapes the component boundary.-- `MC`/`MI`/`MA` `H`/`L`/`N` — the impact in this codebase. `not_imported` code- the build still ships is usually `N` across all three.-- `CR`/`IR`/`AR` `H`/`M`/`L` — the security requirement of the data or service- the package handles (credentials or payment data raise `CR`).+- Set `contextual_cvss_breakdown` + `contextual_cvss_reasoning` when this+ codebase clearly changes the risk the published score describes (see below).++### Contextual CVSS++The published score rates the CVE in the abstract. `contextual_cvss_breakdown`+rates it **here**, in this codebase — the same 8-metric CVSS v3.1 object as a+normal finding's `cvss_breakdown` (`attack_vector`, `attack_complexity`,+`privileges_required`, `user_interaction`, `scope`, `confidentiality`,+`integrity`, `availability`). You never pass a score: the contextual score and+vector are computed from the breakdown, and when you provide one it determines+the finding's severity. `advisory_cvss` stays the published reference.++Start from the advisory's own published metrics and change only what your+evidence proves is different in this codebase:++- `attack_vector` `N`/`A`/`L`/`P` — as deployed. A library reached only by a+ local CLI is `L`, not `N`.+- `attack_complexity` `L`/`H` — raise to `H` when the vulnerable path needs a+ precondition the code enforces (input validation, a non-default flag, an+ internal-only route).+- `privileges_required` `N`/`L`/`H`, `user_interaction` `N`/`R` — what this+ deployment requires before the path is reachable.+- `scope` `U`/`C` — whether exploitation here escapes the component boundary.+- `confidentiality`/`integrity`/`availability` `N`/`L`/`H` — the impact in this+ codebase. `not_imported` code the build still ships is usually `N` across all+ three.Ground every metric in the **source-to-sink trace** from the usage analysis(step 3 above), not in a general impression of the package. Derive the metrics-from that chain: `MAV`, `MPR`, and `MUI` come from what the source requires;-`MAC` comes from the preconditions the hops enforce; `MC`, `MI`, and `MA` come-from the data and privileges available at the sink; `CR`, `IR`, and `AR` come-from what that data is worth.+from that chain: `attack_vector`, `privileges_required`, and `user_interaction`+come from what the source requires; `attack_complexity` comes from the+preconditions the hops enforce; `confidentiality`, `integrity`, and+`availability` come from the data and privileges available at the sink.-No trace, no contextual metrics: if you did not reach a symbol hit, or you+No trace, no contextual breakdown: if you did not reach a symbol hit, or youcould not follow a hop, omit the contextual fields instead of guessing.-`contextual_cvss_reasoning` is required with the metrics. Write two to four+`contextual_cvss_reasoning` is required with the breakdown. Write two to foursentences that another engineer can check without opening the repository. Namethe chain hop by hop as `entry point -> intermediate call -> package call`, witha repository-relative `file:line` for each hop, say who controls the input, and-say what the adjustment changes. Example: `{"MAC": "H", "MC": "L"}` with "The-only caller of `yaml.load` is `parse_manifest` in `scripts/import.py:88`, which-`cli/commands.py:212` invokes for an operator-supplied path behind the-`--allow-unsafe-import` flag that `deploy/prod.yaml` never sets. No HTTP route-reaches that function, so an attacker must already hold shell access on the job-host, and the parsed data is build metadata rather than customer records."+say what the contextual rating changes. Example: lowering `attack_vector` to+`L` and `confidentiality` to `L` with "The only caller of `yaml.load` is+`parse_manifest` in `scripts/import.py:88`, which `cli/commands.py:212` invokes+for an operator-supplied path behind the `--allow-unsafe-import` flag that+`deploy/prod.yaml` never sets. No HTTP route reaches that function, so an+attacker must already hold shell access on the job host, and the parsed data is+build metadata rather than customer records."Omit all the contextual fields when the published rating already fits, and when-the evidence is thin. A contextual score is a claim you must be able to defend,-and this adjustment never replaces `advisory_cvss`.+the evidence is thin. A contextual rating is a claim you must be able to+defend, and it never replaces `advisory_cvss` as the published reference.Verify the CVE with `web_search` when available before reporting. Never guess orhallucinate a CVE id.@@ -308,12 +313,12 @@ hallucinate a CVE id.`create_dependency_report`.- Do not report a finding without a verified CVE id.- Do not batch multiple CVEs into one report.-- Do not omit `advisory_cvss` — the tool rejects it, and it is the single input- that determines dependency severity.+- Do not omit `advisory_cvss` — the tool rejects it, and it rates every finding+ that carries no contextual breakdown.- Do not silently drop a known CVE because it lacks a dynamic PoC — that is theexact failure this skill prevents.- Do not downgrade advisory severity for lack of dynamic reproduction.- Do not claim a `reachability` level the evidence does not prove — `unknown`with a reason is always acceptable; an overclaimed level never is.-- Do not send `contextual_cvss_metrics` without evidence-backed reasoning, and+- Do not send `contextual_cvss_breakdown` without evidence-backed reasoning, anddo not use it to quietly de-rate a CVE you simply could not analyze.diff --git a/strix/tools/reporting/tool.py b/strix/tools/reporting/tool.pyindex 1fb7b83f..55d711d3 100644--- a/strix/tools/reporting/tool.py+++ b/strix/tools/reporting/tool.py@@ -749,37 +749,59 @@ def _validate_manifest_path(manifest_path: str | None) -> str | None:return None-# CVSS v3.1 environmental metrics an agent may set on a dependency finding,-# with their legal values. The base metrics are deliberately absent: they come-# from the published advisory, so a report can never restate them.-_CVSS_ENVIRONMENTAL_VALUES: dict[str, frozenset[str]] = {- "MAV": frozenset("NALP"),- "MAC": frozenset("LH"),- "MPR": frozenset("NLH"),- "MUI": frozenset("NR"),- "MS": frozenset("UC"),- "MC": frozenset("HLN"),- "MI": frozenset("HLN"),- "MA": frozenset("HLN"),- "CR": frozenset("HML"),- "IR": frozenset("HML"),- "AR": frozenset("HML"),-}_MAX_CONTEXTUAL_REASONING_CHARS = 2000-def _clean_contextual_cvss_metrics(raw: dict[str, str] | None) -> dict[str, str]:- """Keep only well-formed CVSS environmental metrics from a report."""- if not isinstance(raw, dict):- return {}- metrics: dict[str, str] = {}- for key, value in raw.items():- metric = str(key or "").strip().upper()- metric_value = str(value or "").strip().upper()- allowed = _CVSS_ENVIRONMENTAL_VALUES.get(metric)- if allowed and metric_value in allowed:- metrics[metric] = metric_value- return metrics+def _validate_contextual_cvss(+ breakdown: dict[str, str] | None,+ reasoning: str | None,+) -> list[str]:+ errors: list[str] = []+ if breakdown:+ for name, valid in _CVSS_VALID.items():+ value = breakdown.get(name)+ if value not in valid:+ errors.append(+ f"Invalid contextual_cvss_breakdown {name}: {value}. Must be one of: {valid}"+ )+ if not (reasoning or "").strip():+ errors.append(+ "contextual_cvss_reasoning is required when contextual_cvss_breakdown is "+ "set: state what you observed in this codebase that justifies the "+ "contextual rating. A contextual score with no reasoning is not shown."+ )+ return errors+++def _validate_advisory_cvss(advisory_cvss: float | None) -> str | None:+ if advisory_cvss is None:+ return (+ "advisory_cvss is required: read the published advisory base score "+ "(0.0-10.0) off the advisory (trivy CVSS / NVD / GHSA). It is the "+ "published reference the finding is rated against — do not omit it "+ "or the finding cannot be rated."+ )+ if not 0.0 <= advisory_cvss <= 10.0:+ return f"advisory_cvss must be between 0.0 and 10.0, got {advisory_cvss}"+ return None+++def _resolve_dependency_rating(+ advisory_cvss: float | None,+ contextual_cvss_breakdown: dict[str, str] | None,+) -> tuple[float | None, str, float | None, str | None]:+ """Rate the finding.++ A contextual breakdown works exactly like a normal finding's+ ``cvss_breakdown``: the agent supplies the 8 metrics as observed in this+ codebase and the score/vector are computed from them. When provided it+ rates the finding; the advisory score stays as the published reference.+ """+ if contextual_cvss_breakdown:+ score, severity, vector = _calculate_cvss(contextual_cvss_breakdown)+ return score, severity, score, vector+ score, severity = _dependency_severity(advisory_cvss)+ return score, severity, None, Nonedef _build_dependency_metadata(@@ -793,13 +815,18 @@ def _build_dependency_metadata(manifest_path: str | None = None,reachability: str | None = None,reachability_evidence: str | None = None,- contextual_cvss_metrics: dict[str, str] | None = None,+ advisory_cvss: float | None = None,+ contextual_cvss_breakdown: dict[str, str] | None = None,+ contextual_cvss_score: float | None = None,+ contextual_cvss_vector: str | None = None,contextual_cvss_reasoning: str | None = None,) -> dict[str, Any]:metadata: dict[str, Any] = {"package_name": package_name.strip(),"installed_version": installed_version.strip(),}+ if advisory_cvss is not None:+ metadata["advisory_cvss"] = advisory_cvssif package_ecosystem and package_ecosystem.strip():metadata["package_ecosystem"] = package_ecosystem.strip()if manifest_path and manifest_path.strip():@@ -816,12 +843,19 @@ def _build_dependency_metadata(metadata["reachability"] = reachability.strip()if reachability_evidence and reachability_evidence.strip():metadata["reachability_evidence"] = reachability_evidence.strip()- # Contextual CVSS is only meaningful as metrics plus the reasoning a reader- # can check, so an incomplete pair is dropped.- cleaned_metrics = _clean_contextual_cvss_metrics(contextual_cvss_metrics)+ # Contextual CVSS is only meaningful as the full breakdown, its computed+ # score/vector, and the reasoning a reader can check — an incomplete set+ # is dropped.reasoning = str(contextual_cvss_reasoning or "").strip()- if cleaned_metrics and reasoning:- metadata["contextual_cvss_metrics"] = cleaned_metrics+ if (+ contextual_cvss_breakdown+ and contextual_cvss_score is not None+ and contextual_cvss_vector+ and reasoning+ ):+ metadata["contextual_cvss_breakdown"] = contextual_cvss_breakdown+ metadata["contextual_cvss_score"] = contextual_cvss_score+ metadata["contextual_cvss_vector"] = contextual_cvss_vectormetadata["contextual_cvss_reasoning"] = reasoning[:_MAX_CONTEXTUAL_REASONING_CHARS]return metadata@@ -894,7 +928,7 @@ async def _do_create_dependency( # noqa: PLR0912manifest_path: str | None = None,reachability: str = "unknown",reachability_evidence: str | None = None,- contextual_cvss_metrics: dict[str, str] | None = None,+ contextual_cvss_breakdown: dict[str, str] | None = None,contextual_cvss_reasoning: str | None = None,agent_id: str | None = None,agent_name: str | None = None,@@ -948,28 +982,21 @@ async def _do_create_dependency( # noqa: PLR0912"govulncheck call path). Never claim a reachability level without evidence.")- if _clean_contextual_cvss_metrics(contextual_cvss_metrics) and not (- contextual_cvss_reasoning or ""- ).strip():- errors.append(- "contextual_cvss_reasoning is required when contextual_cvss_metrics is set: "- "state in one or two sentences what you observed in this codebase that "- "justifies the adjustment. An adjusted score with no reasoning is not shown."- )+ errors.extend(_validate_contextual_cvss(contextual_cvss_breakdown, contextual_cvss_reasoning))- if advisory_cvss is None:- errors.append(- "advisory_cvss is required: read the published advisory base score "- "(0.0-10.0) off the advisory (trivy CVSS / NVD / GHSA). Severity is "- "derived solely from it — do not omit it or the finding cannot be rated."- )- elif not 0.0 <= advisory_cvss <= 10.0:- errors.append(f"advisory_cvss must be between 0.0 and 10.0, got {advisory_cvss}")+ advisory_err = _validate_advisory_cvss(advisory_cvss)+ if advisory_err:+ errors.append(advisory_err)if errors:return {"success": False, "error": "Validation failed", "errors": errors}- cvss_score, severity = _dependency_severity(advisory_cvss)+ try:+ cvss_score, severity, contextual_score, contextual_vector = _resolve_dependency_rating(+ advisory_cvss, contextual_cvss_breakdown+ )+ except ValueError as exc:+ return {"success": False, "error": "Validation failed", "errors": [str(exc)]}dependency_metadata = _build_dependency_metadata(package_name=package_name,installed_version=installed_version,@@ -980,7 +1007,10 @@ async def _do_create_dependency( # noqa: PLR0912manifest_path=manifest_path,reachability=reachability,reachability_evidence=reachability_evidence,- contextual_cvss_metrics=contextual_cvss_metrics,+ advisory_cvss=advisory_cvss,+ contextual_cvss_breakdown=contextual_cvss_breakdown,+ contextual_cvss_score=contextual_score,+ contextual_cvss_vector=contextual_vector,contextual_cvss_reasoning=contextual_cvss_reasoning,)evidence = _build_dependency_evidence(@@ -1093,7 +1123,7 @@ async def create_dependency_report(dependency_path: str | None = None,reachability: str = "unknown",reachability_evidence: str | None = None,- contextual_cvss_metrics: dict[str, str] | None = None,+ contextual_cvss_breakdown: dict[str, str] | None = None,contextual_cvss_reasoning: str | None = None,) -> str:"""File a known-CVE dependency (SCA) finding — one report per CVE x package.@@ -1137,8 +1167,10 @@ async def create_dependency_report(proved a path from application code to the vulnerable function.- ``unknown`` — usage analysis was not performed or was inconclusive.- Severity is still derived solely from ``advisory_cvss`` — the- reachability level never changes the rating, only prioritization.+ Severity comes from ``contextual_cvss_breakdown`` when you provide one+ (computed exactly like a normal finding's ``cvss_breakdown``), otherwise+ from ``advisory_cvss``. The reachability level alone never changes the+ rating, only prioritization.**Formatting**: use markdown in text fields (``**bold**``, ``inlinecode`` for package/version identifiers, fenced code blocks for@@ -1159,8 +1191,9 @@ async def create_dependency_report(cwe: ``CWE-NNN`` (most specific) if certain, else omit.advisory_cvss: **Required.** Published advisory base score(0.0-10.0) — read it off the advisory (trivy CVSS / NVD / GHSA).- Severity is derived solely from this score, so it must be the- real published value; do not guess or omit it.+ It is the published reference the finding is rated against and+ rates the finding whenever you give no contextual breakdown, so+ it must be the real published value; do not guess or omit it.technical_analysis: Optional deeper mechanism/root-cause detail.fix_effort: One of ``trivial`` / ``low`` / ``medium`` / ``high``(dependency upgrades are usually ``trivial``/``low``).@@ -1199,26 +1232,29 @@ async def create_dependency_report(is off in production), and say who controls the input. Stateit plainly when no entry point reaches the sink — that is themost useful result a reader can get.- contextual_cvss_metrics: Optional CVSS v3.1 **environmental**- metrics that reframe the published score for this codebase,- as a mapping of metric to value: ``MAV`` (N/A/L/P), ``MAC``- (L/H), ``MPR`` (N/L/H), ``MUI`` (N/R), ``MS`` (U/C), ``MC`` /- ``MI`` / ``MA`` (H/L/N), ``CR`` / ``IR`` / ``AR`` (H/M/L).- Set only the metrics your evidence supports (for example- ``{"MAC": "H", "MC": "L"}`` when the vulnerable path needs a- precondition this deployment enforces and the data at risk is- limited). Derive every value from the **source-to-sink- trace** you recorded in ``reachability_evidence``: adjust- ``MAV`` / ``MPR`` / ``MUI`` from what the entry point- actually requires, ``MAC`` from the preconditions the hops- enforce, and ``MC`` / ``MI`` / ``MA`` from the data and- privileges reachable at the sink. You never supply base- metrics or a score: the base vector comes from the advisory- and the adjusted score is computed from the resulting vector.- Omit the field when the trace does not change the published- rating, or when you could not complete the trace.+ contextual_cvss_breakdown: Optional full CVSS v3.1 rating of this+ CVE **in this codebase** — the same 8-metric object as+ ``create_vulnerability_report``'s ``cvss_breakdown``:+ ``attack_vector`` (N/A/L/P), ``attack_complexity`` (L/H),+ ``privileges_required`` (N/L/H), ``user_interaction`` (N/R),+ ``scope`` (U/C), ``confidentiality`` / ``integrity`` /+ ``availability`` (N/L/H). All 8 metrics are required when the+ field is set, and the contextual score/vector are computed+ from them — you never supply a score. Start from the+ advisory's published metrics and change only what the+ **source-to-sink trace** you recorded in+ ``reachability_evidence`` proves is different here: derive+ ``attack_vector`` / ``privileges_required`` /+ ``user_interaction`` from what the entry point actually+ requires, ``attack_complexity`` from the preconditions the+ hops enforce, and the impact metrics from the data and+ privileges reachable at the sink. When provided, this rating+ determines the finding's severity; ``advisory_cvss`` stays as+ the published reference. Omit the field when the trace does+ not change the published rating, or when you could not+ complete the trace.contextual_cvss_reasoning: **Required whenever**- ``contextual_cvss_metrics`` is set. Two to four detailed+ ``contextual_cvss_breakdown`` is set. Two to four detailedsentences that a reviewer can verify without opening the repo:how the application uses the package, which call sites orconfiguration you inspected (repo-relative ``file:line``),@@ -1254,7 +1290,7 @@ async def create_dependency_report(manifest_path=manifest_path,reachability=reachability,reachability_evidence=reachability_evidence,- contextual_cvss_metrics=contextual_cvss_metrics,+ contextual_cvss_breakdown=contextual_cvss_breakdown,contextual_cvss_reasoning=contextual_cvss_reasoning,agent_id=agent_id,agent_name=agent_name,diff --git a/tests/test_reporting_fields.py b/tests/test_reporting_fields.pyindex 2fa78547..d19f7aec 100644--- a/tests/test_reporting_fields.py+++ b/tests/test_reporting_fields.py@@ -160,6 +160,7 @@ async def test_dependency_report_sets_class_and_metadata(report_state: ReportStaassert report["dependency_metadata"] == {"package_name": "lodash","installed_version": "4.17.20",+ "advisory_cvss": 7.2,"package_ecosystem": "npm","manifest_path": "package-lock.json","fixed_version": "4.17.21",@@ -463,6 +464,7 @@ async def test_dependency_report_dedupe_candidate_includes_dependency_metadata("dependency_metadata": {"package_name": "sample","installed_version": "1.0.0",+ "advisory_cvss": 0.0,"package_ecosystem": "npm","manifest_path": "package-lock.json","fixed_version": "1.0.1",@@ -882,17 +884,29 @@ def test_vuln_tool_exposes_new_params() -> None:def test_dep_tool_exposes_contextual_cvss_params() -> None:dep_props = create_dependency_report.params_json_schema["properties"]for field in (- "contextual_cvss_metrics",+ "contextual_cvss_breakdown","contextual_cvss_reasoning",):assert field in dep_props- assert "source-to-sink" in dep_props["contextual_cvss_metrics"]["description"].lower()+ assert "source-to-sink" in dep_props["contextual_cvss_breakdown"]["description"].lower()assert "source-to-sink" in dep_props["reachability_evidence"]["description"].lower()assert "file:line" in dep_props["contextual_cvss_reasoning"]["description"].lower()+_CONTEXTUAL_BREAKDOWN = {+ "attack_vector": "L",+ "attack_complexity": "H",+ "privileges_required": "H",+ "user_interaction": "N",+ "scope": "U",+ "confidentiality": "L",+ "integrity": "L",+ "availability": "N",+}++@pytest.mark.asyncio-async def test_dependency_report_keeps_only_valid_contextual_metrics(+async def test_dependency_report_computes_contextual_cvss(report_state: ReportState,) -> None:result = await _do_create_dependency(@@ -912,18 +926,87 @@ async def test_dependency_report_keeps_only_valid_contextual_metrics(cwe="CWE-94",fix_effort="trivial",manifest_path="package-lock.json",- contextual_cvss_metrics={"MAC": "H", "MC": "L", "AV": "N", "MPR": "Z"},+ contextual_cvss_breakdown=_CONTEXTUAL_BREAKDOWN,contextual_cvss_reasoning="Only scripts/import.py reaches the sink.",)assert result["success"] is True, result- metadata = report_state.vulnerability_reports[0]["dependency_metadata"]- assert metadata["contextual_cvss_metrics"] == {"MAC": "H", "MC": "L"}+ report = report_state.vulnerability_reports[0]+ metadata = report["dependency_metadata"]+ assert metadata["advisory_cvss"] == 7.2+ assert metadata["contextual_cvss_breakdown"] == _CONTEXTUAL_BREAKDOWN+ assert metadata["contextual_cvss_vector"] == ("CVSS:3.1/AV:L/AC:H/PR:H/UI:N/S:U/C:L/I:L/A:N")+ assert metadata["contextual_cvss_score"] == pytest.approx(3.0, abs=0.05)assert metadata["contextual_cvss_reasoning"] == "Only scripts/import.py reaches the sink."- assert "contextual_cvss_metric_reasoning" not in metadata+ # The contextual rating determines the finding's score/severity, exactly+ # like a normal finding's cvss_breakdown.+ assert report["cvss"] == metadata["contextual_cvss_score"]+ assert report["severity"] == "low"+++async def test_dependency_report_rates_from_advisory_without_contextual(+ report_state: ReportState,+) -> None:+ result = await _do_create_dependency(+ title="CVE-2021-23337 in lodash 4.17.20",+ description="Command injection via template.",+ target="repo/package.json",+ cve="CVE-2021-23337",+ package_name="lodash",+ installed_version="4.17.20",+ impact="Arbitrary command execution.",+ remediation_steps="Upgrade to 4.17.21.",+ assumptions="Assumes the template sink is reachable.",+ package_ecosystem="npm",+ advisory_cvss=7.2,+ technical_analysis=None,+ fixed_version="4.17.21",+ cwe="CWE-94",+ fix_effort="trivial",+ manifest_path="package-lock.json",+ )+ assert result["success"] is True, result+ report = report_state.vulnerability_reports[0]+ assert report["cvss"] == 7.2+ assert report["severity"] == "high"+ metadata = report["dependency_metadata"]+ assert metadata["advisory_cvss"] == 7.2+ assert "contextual_cvss_breakdown" not in metadata+ assert "contextual_cvss_score" not in metadata+++async def test_dependency_report_rejects_incomplete_contextual_breakdown(+ report_state: ReportState,+) -> None:+ result = await _do_create_dependency(+ title="CVE-2021-23337 in lodash 4.17.20",+ description="Command injection via template.",+ target="repo/package.json",+ cve="CVE-2021-23337",+ package_name="lodash",+ installed_version="4.17.20",+ impact="Arbitrary command execution.",+ remediation_steps="Upgrade to 4.17.21.",+ assumptions="Assumes the template sink is reachable.",+ package_ecosystem="npm",+ advisory_cvss=7.2,+ technical_analysis=None,+ fixed_version="4.17.21",+ cwe="CWE-94",+ fix_effort="trivial",+ manifest_path="package-lock.json",+ contextual_cvss_breakdown={"attack_vector": "L", "attack_complexity": "Z"},+ contextual_cvss_reasoning="Only scripts/import.py reaches the sink.",+ )+ assert result["success"] is False+ assert any("attack_complexity" in error for error in result["errors"])+ assert any("privileges_required" in error for error in result["errors"])+ assert report_state.vulnerability_reports == []@pytest.mark.asyncio-async def test_dependency_report_rejects_contextual_metrics_without_reasoning(+async def test_dependency_report_rejects_contextual_breakdown_without_reasoning(report_state: ReportState,) -> None:result = await _do_create_dependency(@@ -943,7 +1026,7 @@ async def test_dependency_report_rejects_contextual_metrics_without_reasoning(cwe="CWE-94",fix_effort="trivial",manifest_path="package-lock.json",- contextual_cvss_metrics={"MAC": "H"},+ contextual_cvss_breakdown=_CONTEXTUAL_BREAKDOWN,contextual_cvss_reasoning=" ",)assert result["success"] is False