attackmap 0.4.25__tar.gz → 0.4.27__tar.gz

{attackmap-0.4.25/src/attackmap.egg-info → attackmap-0.4.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attackmap
-Version: 0.4.25
+Version: 0.4.27
 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>
@@ -790,10 +790,12 @@ scaffolding, testing, and publishing instructions is in
 
 ```bash
 attackmap analyze <path>                 # run a review on a repository
+attackmap analyze repoA repoB gateway    # multi-repo fleet scan (per-repo reports + fleet summary)
 attackmap analyze <path> --output dir    # write outputs to `dir/`
 attackmap analyze <path> --format json   # json | markdown | all (default)
 attackmap analyze <path> --module python --module rust   # only these analyzers
 attackmap analyze <path> --cve           # cross-reference SBOM against OSV.dev
+attackmap analyze <path> --recall        # widen taint discovery (deeper hops, capability-reach); extra reach marked SPECULATIVE
 attackmap analyze <path> --llm           # add LLM narrative (auto-resolve auth)
 attackmap analyze <path> --llm --llm-backend cli         # force Claude CLI
 attackmap analyze <path> --llm --llm-provider openai     # use OpenAI/Codex (OPENAI_API_KEY or `codex` CLI)
@@ -803,6 +805,8 @@ attackmap analyze <path> --hunt --verify # adjudicate each lead vs. source (conf
 attackmap analyze <path> --hunt --verify --verify-votes 3   # majority vote of N independent skeptics (default 3; 1 = single pass)
 attackmap analyze <path> --hunt --verify --hunt-lenses 4     # N lens-specialised generation passes, deduped, then verified
 attackmap analyze <path> --hunt --verify --hunt-rounds 4     # loop-until-dry generation (completeness critic seeds each round)
+attackmap analyze <path> --hunt --verify --hunt-budget 500000  # cap total hunt output tokens across rounds
+attackmap analyze <path> --recall --hunt --verify   # widen the net, then adjudicate the speculative reach
 attackmap analyze <path> --remediate     # LLM review-first fix suggestions (remediation.md)
 attackmap analyze <path> --triage        # cluster/dedupe/rank existing findings (triage.md; deterministic fallback)
 attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for CI
@@ -849,7 +853,7 @@ introduces a new HIGH finding.
 
 ## Project status
 
-AttackMap is **beta** (v0.4.18) — published and validated on real codebases, but
+AttackMap is **beta** (v0.4.25) — published and validated on real codebases, but
 pre-1.0 and heuristic.
 
 **Solid today:**
@@ -867,13 +871,27 @@ pre-1.0 and heuristic.
 - BOLA/IDOR authorization detection (with custom-middleware / guard-arg awareness).
 - Insecure-crypto / weak-randomness (Python/JS/Go/PHP) and web-hardening
   (CORS/CSRF/cookies/CSP/debug) detection.
-- Anomaly / outlier detection and **exploitability fusion** — a deterministic,
-  explainable 0–100 "exploitable now" score that ranks route→sink combinations
-  and folds in known-vulnerable dependencies on the path.
-- **`--hunt`** (LLM exploit-chain hypotheses) with **`--verify`** (adjudicate
-  each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the actual source),
-  **`--remediate`** (review-first fix suggestions), and **`--triage`**
-  (cluster/dedupe/rank existing findings, with a deterministic fallback).
+- Anomaly / outlier detection — including **signature-free invariant mining**
+  (flag the handler that reaches a dangerous sink without the guard its peers
+  apply) — and **exploitability fusion**, a deterministic, explainable 0–100
+  "exploitable now" score that ranks route→sink combinations and folds in
+  known-vulnerable dependencies on the path.
+- **`--hunt`** (LLM exploit-chain hypotheses) with a **verify jury** —
+  **`--verify`** adjudicates each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the
+  actual source; **`--verify-votes`** runs N independent skeptics, **`--hunt-lenses`**
+  fans generation across failure-mode specialists, **`--hunt-rounds`** loops
+  until dry with a completeness critic, **`--hunt-budget`** caps token spend —
+  plus **`--remediate`** (review-first fixes) and **`--triage`**
+  (cluster/dedupe/rank existing findings, deterministic fallback).
+- **`--recall`** — verifier-gated aggressive discovery: widens the taint walk
+  (deeper hops, capability-reach enumeration of every reach to exec/fs/net/
+  deserialize/template/SQL) and marks the extra reach SPECULATIVE, kept out of
+  `--fail-on-new-high` and left for `--hunt --verify` to adjudicate.
+- **Cross-repo / fleet analysis** — `attackmap analyze repoA repoB …` scans a
+  fleet, links one repo's outbound HTTP calls to another's routes, and surfaces
+  bugs that live in the seams: cross-boundary (confused-deputy) flows,
+  trust-assumption gaps, and the sibling service that omits a control its peers
+  enforce. All cross-repo findings are speculative until verified.
 - SBOM inventory (5 ecosystems) + OSV.dev CVE cross-reference (`--cve`).
 - Output: Markdown + JSON + **SARIF 2.1.0** + **Mermaid / Graphviz** diagrams;
   **diff/baseline** PR gating; a reusable **GitHub Action + PR bot**; optional

{attackmap-0.4.25 → attackmap-0.4.27}/README.md

@@ -729,10 +729,12 @@ scaffolding, testing, and publishing instructions is in
 
 ```bash
 attackmap analyze <path>                 # run a review on a repository
+attackmap analyze repoA repoB gateway    # multi-repo fleet scan (per-repo reports + fleet summary)
 attackmap analyze <path> --output dir    # write outputs to `dir/`
 attackmap analyze <path> --format json   # json | markdown | all (default)
 attackmap analyze <path> --module python --module rust   # only these analyzers
 attackmap analyze <path> --cve           # cross-reference SBOM against OSV.dev
+attackmap analyze <path> --recall        # widen taint discovery (deeper hops, capability-reach); extra reach marked SPECULATIVE
 attackmap analyze <path> --llm           # add LLM narrative (auto-resolve auth)
 attackmap analyze <path> --llm --llm-backend cli         # force Claude CLI
 attackmap analyze <path> --llm --llm-provider openai     # use OpenAI/Codex (OPENAI_API_KEY or `codex` CLI)
@@ -742,6 +744,8 @@ attackmap analyze <path> --hunt --verify # adjudicate each lead vs. source (conf
 attackmap analyze <path> --hunt --verify --verify-votes 3   # majority vote of N independent skeptics (default 3; 1 = single pass)
 attackmap analyze <path> --hunt --verify --hunt-lenses 4     # N lens-specialised generation passes, deduped, then verified
 attackmap analyze <path> --hunt --verify --hunt-rounds 4     # loop-until-dry generation (completeness critic seeds each round)
+attackmap analyze <path> --hunt --verify --hunt-budget 500000  # cap total hunt output tokens across rounds
+attackmap analyze <path> --recall --hunt --verify   # widen the net, then adjudicate the speculative reach
 attackmap analyze <path> --remediate     # LLM review-first fix suggestions (remediation.md)
 attackmap analyze <path> --triage        # cluster/dedupe/rank existing findings (triage.md; deterministic fallback)
 attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for CI
@@ -788,7 +792,7 @@ introduces a new HIGH finding.
 
 ## Project status
 
-AttackMap is **beta** (v0.4.18) — published and validated on real codebases, but
+AttackMap is **beta** (v0.4.25) — published and validated on real codebases, but
 pre-1.0 and heuristic.
 
 **Solid today:**
@@ -806,13 +810,27 @@ pre-1.0 and heuristic.
 - BOLA/IDOR authorization detection (with custom-middleware / guard-arg awareness).
 - Insecure-crypto / weak-randomness (Python/JS/Go/PHP) and web-hardening
   (CORS/CSRF/cookies/CSP/debug) detection.
-- Anomaly / outlier detection and **exploitability fusion** — a deterministic,
-  explainable 0–100 "exploitable now" score that ranks route→sink combinations
-  and folds in known-vulnerable dependencies on the path.
-- **`--hunt`** (LLM exploit-chain hypotheses) with **`--verify`** (adjudicate
-  each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the actual source),
-  **`--remediate`** (review-first fix suggestions), and **`--triage`**
-  (cluster/dedupe/rank existing findings, with a deterministic fallback).
+- Anomaly / outlier detection — including **signature-free invariant mining**
+  (flag the handler that reaches a dangerous sink without the guard its peers
+  apply) — and **exploitability fusion**, a deterministic, explainable 0–100
+  "exploitable now" score that ranks route→sink combinations and folds in
+  known-vulnerable dependencies on the path.
+- **`--hunt`** (LLM exploit-chain hypotheses) with a **verify jury** —
+  **`--verify`** adjudicates each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the
+  actual source; **`--verify-votes`** runs N independent skeptics, **`--hunt-lenses`**
+  fans generation across failure-mode specialists, **`--hunt-rounds`** loops
+  until dry with a completeness critic, **`--hunt-budget`** caps token spend —
+  plus **`--remediate`** (review-first fixes) and **`--triage`**
+  (cluster/dedupe/rank existing findings, deterministic fallback).
+- **`--recall`** — verifier-gated aggressive discovery: widens the taint walk
+  (deeper hops, capability-reach enumeration of every reach to exec/fs/net/
+  deserialize/template/SQL) and marks the extra reach SPECULATIVE, kept out of
+  `--fail-on-new-high` and left for `--hunt --verify` to adjudicate.
+- **Cross-repo / fleet analysis** — `attackmap analyze repoA repoB …` scans a
+  fleet, links one repo's outbound HTTP calls to another's routes, and surfaces
+  bugs that live in the seams: cross-boundary (confused-deputy) flows,
+  trust-assumption gaps, and the sibling service that omits a control its peers
+  enforce. All cross-repo findings are speculative until verified.
 - SBOM inventory (5 ecosystems) + OSV.dev CVE cross-reference (`--cve`).
 - Output: Markdown + JSON + **SARIF 2.1.0** + **Mermaid / Graphviz** diagrams;
   **diff/baseline** PR gating; a reusable **GitHub Action + PR bot**; optional

{attackmap-0.4.25 → attackmap-0.4.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "attackmap"
-version = "0.4.25"
+version = "0.4.27"
 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"

{attackmap-0.4.25 → attackmap-0.4.27}/src/attackmap/cli.py

@@ -126,7 +126,9 @@ def _run_fleet(
         )
         if cve and scan.dependencies:
             try:
-                vulns, _cve_summary = query_vulnerabilities(scan.dependencies)
+                vulns, _cve_summary = query_vulnerabilities(
+                    scan.dependencies, progress=scan_progress
+                )
             finally:
                 scan_progress.done()
             scan.vulnerabilities = vulns
@@ -434,9 +436,13 @@ def analyze(
         )
     if cve and scan.dependencies:
         typer.echo(f"Checking {len(scan.dependencies)} dependencies against OSV.dev…")
-        scan_progress.stage(f"Checking {len(scan.dependencies)} dependencies against OSV.dev")
+        # query_vulnerabilities drives a determinate begin/advance bar itself
+        # (per unique package), so big lockfile trees show real progress + ETA
+        # instead of an indeterminate spinner.
         try:
-            vulns, cve_summary = query_vulnerabilities(scan.dependencies)
+            vulns, cve_summary = query_vulnerabilities(
+                scan.dependencies, progress=scan_progress
+            )
         finally:
             scan_progress.done()
         scan.vulnerabilities = vulns

{attackmap-0.4.25 → attackmap-0.4.27}/src/attackmap/cve.py

@@ -7,9 +7,16 @@ and doesn't belong in an offline-only scan.
 
 ## Design summary
 
-- **Endpoint**: ``POST https://api.osv.dev/v1/query`` per (ecosystem,
-  name, version). Full details in a single response; simpler cache
-  semantics than the batch + fetch-by-id combo.
+- **Endpoints**: ``POST https://api.osv.dev/v1/querybatch`` in chunks of
+  up to ``_BATCH_SIZE`` (ecosystem, name, version) tuples — one request
+  covers hundreds of packages instead of one request per package (a
+  lockfile-resolved monorepo can carry thousands of pinned deps; per-
+  package queries took ~15 minutes on such repos). The batch response
+  carries vulnerability IDs only, so full records are then fetched via
+  ``GET https://api.osv.dev/v1/vulns/{id}`` — but only for the handful
+  of packages that actually have advisories, memoized per run. A batch
+  result that paginates (``next_page_token``, rare) falls back to the
+  classic ``POST /v1/query`` for that one package.
 - **Concrete version resolution**: OSV needs a concrete version to
   match against affected ranges. Manifests carry range specs
   (``^4.16.0``, ``>=2.28,<3``, ``latest``); we extract a best-effort
@@ -48,6 +55,10 @@ logger = logging.getLogger(__name__)
 
 
 _OSV_QUERY_URL = "https://api.osv.dev/v1/query"
+_OSV_BATCH_URL = "https://api.osv.dev/v1/querybatch"
+_OSV_VULNS_URL = "https://api.osv.dev/v1/vulns/"
+# OSV accepts up to 1000 queries per batch call; stay comfortably under.
+_BATCH_SIZE = 500
 _OSV_ECOSYSTEM: dict[str, str] = {
     "pypi": "PyPI",
     "npm": "npm",
@@ -85,6 +96,7 @@ def query_vulnerabilities(
     cache_dir: Path | None = None,
     transport: Callable[[str, bytes], bytes] | None = None,
     clock: Callable[[], float] | None = None,
+    progress=None,
 ) -> tuple[list[Vulnerability], LookupSummary]:
     """Look up CVEs for each ``DependencyHint`` and return records.
 
@@ -98,9 +110,15 @@ def query_vulnerabilities(
         supply a per-test tmpdir here.
     transport
         Injectable network transport ``(url, body) -> response_bytes``.
-        Tests pass a stub; default is urllib.
+        Tests pass a stub; default is urllib. Detail lookups pass an
+        empty body (a GET in the default transport).
     clock
         Injectable ``time.time`` for deterministic cache-TTL tests.
+    progress
+        Optional duck-typed progress sink with ``begin(total, label)``
+        and ``advance(current)`` — the CLI passes its ``ScanProgress``
+        so a long lookup renders as a determinate bar, not a stalled
+        spinner.
     """
     cache = _resolve_cache_dir(cache_dir)
     cache.mkdir(parents=True, exist_ok=True)
@@ -111,6 +129,12 @@ def query_vulnerabilities(
     summary = LookupSummary()
     seen_keys: set[tuple[str, str, str, str]] = set()
 
+    # Pass 1 — resolve each hint to a concrete queryable version and dedupe
+    # to unique (ecosystem, name, version) packages. A lockfile monorepo can
+    # carry thousands of hints; querying per unique package (batched below)
+    # instead of per hint is what keeps --cve tractable.
+    entries: list[tuple[DependencyHint, tuple[str, str, str]]] = []
+    unique: dict[tuple[str, str, str], tuple[str, str, str]] = {}  # key -> (osv_eco, name, concrete)
     for dep in dependencies:
         osv_eco = _OSV_ECOSYSTEM.get(dep.ecosystem)
         if osv_eco is None:
@@ -125,21 +149,76 @@ def query_vulnerabilities(
         if concrete is None:
             summary.skipped_no_version += 1
             continue
-
         key = (dep.ecosystem, dep.name, concrete)
-        cache_path = cache / (_cache_key(*key) + ".json")
+        entries.append((dep, key))
+        unique.setdefault(key, (osv_eco, dep.name, concrete))
 
-        payload: dict | None = _read_cache(cache_path, now, ttl_seconds)
+    if progress is not None:
+        progress.begin(len(unique), label="Checking dependencies against OSV.dev")
+
+    # Pass 2 — serve unique packages from the cache where fresh.
+    payload_by_key: dict[tuple[str, str, str], dict] = {}
+    for key in unique:
+        cache_path = cache / (_cache_key(*key) + ".json")
+        payload = _read_cache(cache_path, now, ttl_seconds)
         if payload is not None:
+            payload_by_key[key] = payload
             summary.cached += 1
-        else:
-            payload = _fetch_osv(osv_eco, dep.name, concrete, transport, summary)
+            if progress is not None:
+                progress.advance(key[1])
+
+    # Pass 3 — batch-query the misses (one POST per _BATCH_SIZE packages),
+    # then fetch full advisory records only for the IDs that actually hit,
+    # memoized so a CVE shared by many packages is fetched once.
+    misses = [key for key in unique if key not in payload_by_key]
+    details_memo: dict[str, dict] = {}
+    for start in range(0, len(misses), _BATCH_SIZE):
+        chunk = misses[start : start + _BATCH_SIZE]
+        results = _fetch_osv_batch([unique[key] for key in chunk], transport, summary)
+        if results is None:
+            # Whole batch unreachable — same offline semantics as before,
+            # tallied per package so the summary line stays meaningful.
+            summary.skipped_offline += len(chunk)
+            if progress is not None:
+                for key in chunk:
+                    progress.advance(key[1])
+            continue
+        for key, result in zip(chunk, results):
+            osv_eco, name, concrete = unique[key]
+            payload: dict | None
+            if not isinstance(result, dict):
+                result = {}
+            if result.get("next_page_token"):
+                # A package with >1 page of advisories (rare): fall back to
+                # the classic single query, following ITS pagination too —
+                # exactly these high-advisory packages paginate there as well.
+                payload = _fetch_osv_paged(osv_eco, name, concrete, transport, summary)
+            else:
+                # Assemble the full advisory records for this package. If any
+                # detail fetch fails, the package must NOT be cached — a
+                # partial payload would suppress a known vulnerability for the
+                # whole cache TTL. Treat it as offline for this run instead.
+                payload = _assemble_details(result, details_memo, transport, summary)
             if payload is None:
-                continue  # skipped_offline / network_errors already tallied
-            _write_cache(cache_path, payload, now)
+                summary.skipped_offline += 1
+                if progress is not None:
+                    progress.advance(name)
+                continue
+            payload_by_key[key] = payload
+            _write_cache(cache / (_cache_key(*key) + ".json"), payload, now)
             summary.queried += 1
-            if transport is None:
-                time.sleep(_INTER_REQUEST_SLEEP_S)
+            if progress is not None:
+                progress.advance(name)
+        if transport is None and start + _BATCH_SIZE < len(misses):
+            time.sleep(_INTER_REQUEST_SLEEP_S)
+
+    # Pass 4 — fan the per-package payloads back out to every hint (dedup by
+    # (eco, name, version, id) keeps multi-lockfile repeats from double-emitting).
+    for dep, key in entries:
+        payload = payload_by_key.get(key)
+        if payload is None:
+            continue
+        concrete = key[2]
 
         for entry in payload.get("vulns") or []:
             vuln = _entry_to_vulnerability(entry, dep, concrete)
@@ -404,37 +483,151 @@ def _write_cache(path: Path, payload: dict, now: float) -> None:
         pass
 
 
-def _fetch_osv(
+def _fetch_osv_batch(
+    packages: list[tuple[str, str, str]],
+    transport: Callable[[str, bytes], bytes] | None,
+    summary: LookupSummary,
+) -> list[dict] | None:
+    """One ``POST /v1/querybatch`` for up to ``_BATCH_SIZE`` packages.
+
+    Returns the ``results`` list (aligned with ``packages`` by index — OSV
+    guarantees request order) or ``None`` on a network/shape failure, in
+    which case the whole chunk is treated as offline.
+    """
+    body = json.dumps(
+        {
+            "queries": [
+                {"package": {"name": name, "ecosystem": osv_eco}, "version": version}
+                for osv_eco, name, version in packages
+            ]
+        }
+    ).encode("utf-8")
+    raw = _http(_OSV_BATCH_URL, body, transport, summary)
+    if raw is None:
+        return None
+    try:
+        payload = json.loads(raw.decode("utf-8") if isinstance(raw, bytes) else raw)
+    except json.JSONDecodeError:
+        summary.network_errors += 1
+        return None
+    results = payload.get("results") if isinstance(payload, dict) else None
+    if not isinstance(results, list) or len(results) != len(packages):
+        summary.network_errors += 1
+        return None
+    return results
+
+
+def _assemble_details(
+    result: dict,
+    details_memo: dict[str, dict],
+    transport: Callable[[str, bytes], bytes] | None,
+    summary: LookupSummary,
+) -> dict | None:
+    """Turn one batch result's ID references into full advisory records.
+
+    Returns ``None`` if any advertised detail could not be fetched — the
+    caller must then skip caching the package, because caching a partial
+    payload would suppress a known vulnerability for the whole TTL (P1).
+    """
+    full_entries = []
+    for ref in result.get("vulns") or []:
+        vuln_id = str(ref.get("id", "")) if isinstance(ref, dict) else ""
+        if not vuln_id:
+            continue  # shape anomaly, not a fetch failure — nothing to fetch
+        entry = details_memo.get(vuln_id)
+        if entry is None:
+            entry = _fetch_osv_vuln(vuln_id, transport, summary)
+            if entry is None:
+                return None
+            details_memo[vuln_id] = entry
+        full_entries.append(entry)
+    return {"vulns": full_entries} if full_entries else {}
+
+
+def _fetch_osv_paged(
     osv_ecosystem: str,
     name: str,
     version: str,
     transport: Callable[[str, bytes], bytes] | None,
     summary: LookupSummary,
 ) -> dict | None:
-    body = json.dumps(
-        {"package": {"name": name, "ecosystem": osv_ecosystem}, "version": version}
-    ).encode("utf-8")
+    """Classic ``POST /v1/query``, following ``next_page_token`` to the end.
+
+    Returns the union of all pages' ``vulns``, or ``None`` if any page fails
+    — never a partial result, for the same don't-cache-partials reason as
+    :func:`_assemble_details` (P2: single-query responses paginate too).
+    """
+    all_vulns: list[dict] = []
+    page_token: str | None = None
+    while True:
+        query: dict = {
+            "package": {"name": name, "ecosystem": osv_ecosystem},
+            "version": version,
+        }
+        if page_token:
+            query["page_token"] = page_token
+        raw = _http(_OSV_QUERY_URL, json.dumps(query).encode("utf-8"), transport, summary)
+        if raw is None:
+            return None
+        try:
+            payload = json.loads(raw.decode("utf-8") if isinstance(raw, bytes) else raw)
+        except json.JSONDecodeError:
+            summary.network_errors += 1
+            return None
+        if not isinstance(payload, dict):
+            summary.network_errors += 1
+            return None
+        all_vulns.extend(payload.get("vulns") or [])
+        page_token = payload.get("next_page_token")
+        if not page_token:
+            break
+        if transport is None:
+            time.sleep(_INTER_REQUEST_SLEEP_S)
+    return {"vulns": all_vulns} if all_vulns else {}
+
+
+def _fetch_osv_vuln(
+    vuln_id: str,
+    transport: Callable[[str, bytes], bytes] | None,
+    summary: LookupSummary,
+) -> dict | None:
+    """Fetch one full advisory record via ``GET /v1/vulns/{id}``."""
+    raw = _http(_OSV_VULNS_URL + vuln_id, b"", transport, summary)
+    if raw is None:
+        return None
     try:
-        if transport is not None:
-            raw = transport(_OSV_QUERY_URL, body)
-        else:
-            request = urllib.request.Request(
-                _OSV_QUERY_URL,
-                data=body,
-                headers={"Content-Type": "application/json"},
-                method="POST",
-            )
-            with urllib.request.urlopen(request, timeout=_REQUEST_TIMEOUT_S) as response:
-                raw = response.read()
-    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        entry = json.loads(raw.decode("utf-8") if isinstance(raw, bytes) else raw)
+    except json.JSONDecodeError:
         summary.network_errors += 1
-        summary.skipped_offline += 1
-        logger.debug("OSV network error for %s/%s@%s: %s", osv_ecosystem, name, version, exc)
         return None
+    return entry if isinstance(entry, dict) else None
+
+
+def _http(
+    url: str,
+    body: bytes,
+    transport: Callable[[str, bytes], bytes] | None,
+    summary: LookupSummary,
+) -> bytes | None:
+    """One HTTP exchange: POST when ``body`` is non-empty, GET otherwise.
+
+    The injectable ``transport`` sees ``(url, body)`` either way, so test
+    stubs dispatch on the URL.
+    """
     try:
-        return json.loads(raw.decode("utf-8") if isinstance(raw, bytes) else raw)
-    except json.JSONDecodeError:
+        if transport is not None:
+            return transport(url, body)
+        request = urllib.request.Request(
+            url,
+            data=body or None,
+            headers={"Content-Type": "application/json"} if body else {},
+            method="POST" if body else "GET",
+        )
+        with urllib.request.urlopen(request, timeout=_REQUEST_TIMEOUT_S) as response:
+            return response.read()
+    except (urllib.error.URLError, TimeoutError, OSError) as exc:
         summary.network_errors += 1
+        logger.debug("OSV network error for %s: %s", url, exc)
         return None
 
 

{attackmap-0.4.25 → attackmap-0.4.27}/src/attackmap/lockfiles.py

@@ -263,11 +263,29 @@ def _parse_pnpm_lock(path: Path) -> _Graph | None:
         import yaml
     except ImportError:  # pragma: no cover - PyYAML is a declared dependency
         return None
-    data = yaml.safe_load(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
+    # pnpm-lock is normally a single YAML document, but some files concatenate
+    # several with `---` separators (e.g. a merge artifact, or a tool that
+    # appends per-workspace lockfiles). Parse every document and merge them, and
+    # never let a malformed-YAML error abort the whole scan — a lockfile we can't
+    # read just yields no dependency hints.
+    try:
+        documents = [
+            doc
+            for doc in yaml.safe_load_all(path.read_text(encoding="utf-8"))
+            if isinstance(doc, dict)
+        ]
+    except yaml.YAMLError:
+        return None
+    if not documents:
         return None
     graph = _Graph(ecosystem="npm")
+    for data in documents:
+        _absorb_pnpm_document(data, graph)
+    return graph
 
+
+def _absorb_pnpm_document(data: dict, graph: _Graph) -> None:
+    """Fold one parsed pnpm-lock YAML document into ``graph`` (roots + packages)."""
     # Roots: importers.'.'.{dependencies,devDependencies} (v6+) or top-level.
     importers = data.get("importers")
     root_sections = []
@@ -285,7 +303,7 @@ def _parse_pnpm_lock(path: Path) -> _Graph | None:
 
     packages = data.get("packages")
     if not isinstance(packages, dict):
-        return graph
+        return
     for raw_key, meta in packages.items():
         m = _PNPM_PKG_KEY_RE.match(str(raw_key))
         if not m:
@@ -302,7 +320,6 @@ def _parse_pnpm_lock(path: Path) -> _Graph | None:
                     children.update(deps.keys())
             if children:
                 graph.edges.setdefault(name, set()).update(children)
-    return graph
 
 
 # --- pypi: poetry.lock / uv.lock; cargo: Cargo.lock (all TOML [[package]]) --

{attackmap-0.4.25 → attackmap-0.4.27/src/attackmap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: attackmap
-Version: 0.4.25
+Version: 0.4.27
 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>
@@ -790,10 +790,12 @@ scaffolding, testing, and publishing instructions is in
 
 ```bash
 attackmap analyze <path>                 # run a review on a repository
+attackmap analyze repoA repoB gateway    # multi-repo fleet scan (per-repo reports + fleet summary)
 attackmap analyze <path> --output dir    # write outputs to `dir/`
 attackmap analyze <path> --format json   # json | markdown | all (default)
 attackmap analyze <path> --module python --module rust   # only these analyzers
 attackmap analyze <path> --cve           # cross-reference SBOM against OSV.dev
+attackmap analyze <path> --recall        # widen taint discovery (deeper hops, capability-reach); extra reach marked SPECULATIVE
 attackmap analyze <path> --llm           # add LLM narrative (auto-resolve auth)
 attackmap analyze <path> --llm --llm-backend cli         # force Claude CLI
 attackmap analyze <path> --llm --llm-provider openai     # use OpenAI/Codex (OPENAI_API_KEY or `codex` CLI)
@@ -803,6 +805,8 @@ attackmap analyze <path> --hunt --verify # adjudicate each lead vs. source (conf
 attackmap analyze <path> --hunt --verify --verify-votes 3   # majority vote of N independent skeptics (default 3; 1 = single pass)
 attackmap analyze <path> --hunt --verify --hunt-lenses 4     # N lens-specialised generation passes, deduped, then verified
 attackmap analyze <path> --hunt --verify --hunt-rounds 4     # loop-until-dry generation (completeness critic seeds each round)
+attackmap analyze <path> --hunt --verify --hunt-budget 500000  # cap total hunt output tokens across rounds
+attackmap analyze <path> --recall --hunt --verify   # widen the net, then adjudicate the speculative reach
 attackmap analyze <path> --remediate     # LLM review-first fix suggestions (remediation.md)
 attackmap analyze <path> --triage        # cluster/dedupe/rank existing findings (triage.md; deterministic fallback)
 attackmap analyze <path> --pr-comment pr.md   # Markdown PR summary comment for CI
@@ -849,7 +853,7 @@ introduces a new HIGH finding.
 
 ## Project status
 
-AttackMap is **beta** (v0.4.18) — published and validated on real codebases, but
+AttackMap is **beta** (v0.4.25) — published and validated on real codebases, but
 pre-1.0 and heuristic.
 
 **Solid today:**
@@ -867,13 +871,27 @@ pre-1.0 and heuristic.
 - BOLA/IDOR authorization detection (with custom-middleware / guard-arg awareness).
 - Insecure-crypto / weak-randomness (Python/JS/Go/PHP) and web-hardening
   (CORS/CSRF/cookies/CSP/debug) detection.
-- Anomaly / outlier detection and **exploitability fusion** — a deterministic,
-  explainable 0–100 "exploitable now" score that ranks route→sink combinations
-  and folds in known-vulnerable dependencies on the path.
-- **`--hunt`** (LLM exploit-chain hypotheses) with **`--verify`** (adjudicate
-  each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the actual source),
-  **`--remediate`** (review-first fix suggestions), and **`--triage`**
-  (cluster/dedupe/rank existing findings, with a deterministic fallback).
+- Anomaly / outlier detection — including **signature-free invariant mining**
+  (flag the handler that reaches a dangerous sink without the guard its peers
+  apply) — and **exploitability fusion**, a deterministic, explainable 0–100
+  "exploitable now" score that ranks route→sink combinations and folds in
+  known-vulnerable dependencies on the path.
+- **`--hunt`** (LLM exploit-chain hypotheses) with a **verify jury** —
+  **`--verify`** adjudicates each lead CONFIRMED/REFUTED/NEEDS-REVIEW against the
+  actual source; **`--verify-votes`** runs N independent skeptics, **`--hunt-lenses`**
+  fans generation across failure-mode specialists, **`--hunt-rounds`** loops
+  until dry with a completeness critic, **`--hunt-budget`** caps token spend —
+  plus **`--remediate`** (review-first fixes) and **`--triage`**
+  (cluster/dedupe/rank existing findings, deterministic fallback).
+- **`--recall`** — verifier-gated aggressive discovery: widens the taint walk
+  (deeper hops, capability-reach enumeration of every reach to exec/fs/net/
+  deserialize/template/SQL) and marks the extra reach SPECULATIVE, kept out of
+  `--fail-on-new-high` and left for `--hunt --verify` to adjudicate.
+- **Cross-repo / fleet analysis** — `attackmap analyze repoA repoB …` scans a
+  fleet, links one repo's outbound HTTP calls to another's routes, and surfaces
+  bugs that live in the seams: cross-boundary (confused-deputy) flows,
+  trust-assumption gaps, and the sibling service that omits a control its peers
+  enforce. All cross-repo findings are speculative until verified.
 - SBOM inventory (5 ecosystems) + OSV.dev CVE cross-reference (`--cve`).
 - Output: Markdown + JSON + **SARIF 2.1.0** + **Mermaid / Graphviz** diagrams;
   **diff/baseline** PR gating; a reusable **GitHub Action + PR bot**; optional