plugin-scanner 2.0.577__tar.gz → 2.0.579__tar.gz

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.577
+Version: 2.0.579
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.577"
+version = "2.0.579"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.577"
+version = "2.0.579"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, and OpenCode."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/guard/aibom_symlink.py

@@ -15,6 +15,7 @@ AibomPathClass = Literal["workspace_relative", "home_relative", "config_root", "
 AibomValidationState = Literal["valid", "broken", "loop", "escape_blocked", "missing"]
 
 _MAX_SYMLINK_HOPS = 16
+_MAX_SYMLINK_TARGET_BYTES = 1024 * 1024
 
 
 @dataclass(frozen=True, slots=True)
@@ -245,12 +246,25 @@ def source_of_truth_metadata_from_inspection(
     }
 
 
+def _read_bounded_file_bytes(path: Path, *, max_bytes: int) -> bytes:
+    chunks: list[bytes] = []
+    remaining = max_bytes
+    with path.open("rb") as handle:
+        while remaining > 0:
+            chunk = handle.read(min(65536, remaining))
+            if not chunk:
+                break
+            chunks.append(chunk)
+            remaining -= len(chunk)
+    return b"".join(chunks)
+
+
 def _content_hash_for_target(path: Path, *, home_dir: Path) -> str | None:
     try:
         if path.is_dir():
             return fingerprint_path_tree(path, home_dir=home_dir)
         if path.is_file():
-            payload = path.read_bytes()[: 1024 * 1024]
+            payload = _read_bounded_file_bytes(path, max_bytes=_MAX_SYMLINK_TARGET_BYTES)
             return fingerprint_text(payload.decode("utf-8", errors="replace"))
     except OSError:
         return None

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/guard/cli/commands.py

@@ -2687,6 +2687,7 @@ def run_guard_command(
         if getattr(args, "perf", False):
             payload["detector_perf"] = _runtime_detector_perf_payload(config)
         payload["supply_chain"] = build_local_supply_chain_posture(store, config, now=_now())
+        payload["aibom"] = build_aibom_status_payload(store, context, generated_at=_now())
         _emit("doctor", payload, getattr(args, "json", False))
         return 0
 

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/guard/inventory_contract.py

@@ -70,6 +70,34 @@ _SENSITIVE_KEY_RE = re.compile(
     re.IGNORECASE,
 )
 _SENSITIVE_VALUE_RE = re.compile(r"(?i)(gh[pousr]_[a-z0-9_]+|sk-[a-z0-9_-]+|guard_live_[a-z0-9_-]+|bearer\s+\S+)")
+_UNSAFE_PATH_MARKERS = (
+    "".join(("/", "Users", "/")),
+    "".join(("/", "home", "/")),
+    "".join(("/", "root", "/")),
+    "".join(("\\", "Users", "\\")),
+    "".join(("/", "var", "/", "folders", "/")),
+    "".join(("/", "workspace", "/")),
+    "".join(("/", "tmp", "/")),
+    "".join(("/", "etc", "/")),
+    "".join(("/", "mnt", "/")),
+)
+_SERIALIZER_UNSAFE_PATH_PATTERN = (
+    r"(?:^|[\s\"'=:({])(?:" + "|".join(re.escape(marker) for marker in _UNSAFE_PATH_MARKERS) + ")"
+)
+_SERIALIZER_UNSAFE_PATH_RE = re.compile(_SERIALIZER_UNSAFE_PATH_PATTERN, re.IGNORECASE)
+_SERIALIZER_SECRET_ASSIGNMENT_RE = re.compile(
+    r"(?i)\b(?:api[_-]?key|authorization|password|secret|token|access[_-]?token|refresh[_-]?token)\b\s*[:=]\s*(?!redacted\b)\S+",
+)
+_SERIALIZER_REDACTED_VALUE = "[REDACTED]"
+_SAFE_SERIALIZED_MARKERS = frozenset(
+    {
+        _SERIALIZER_REDACTED_VALUE,
+        "present_redacted",
+        "present",
+        "redacted",
+        "malformed_url_redacted",
+    }
+)
 _WHITESPACE_RE = re.compile(r"\s+")
 _MCP_READ_RE = re.compile(
     r"(?<![a-z0-9])(read|reads|reading|search|searches|list|lists)(?![a-z0-9])",
@@ -221,6 +249,7 @@ def serialize_inventory_snapshot(snapshot: GuardAgentInventorySnapshot) -> dict[
     payload = _safe_json(asdict(snapshot))
     if not isinstance(payload, dict):
         raise TypeError("Inventory snapshot serialization produced invalid payload.")
+    _assert_serialized_inventory_payload_safe(payload)
     return payload
 
 
@@ -1051,15 +1080,61 @@ def _redact_command_value(value: str, home_dir: Path, workspace_dir: Path | None
     return redacted
 
 
-def _safe_json(value: object) -> object:
+def _sanitize_serializer_string(
+    value: str,
+    *,
+    parent_key: str = "",
+    parent_sensitive: bool = False,
+) -> str:
+    if value in _SAFE_SERIALIZED_MARKERS:
+        return value
+    if parent_sensitive or (parent_key and _SENSITIVE_KEY_RE.search(parent_key)):
+        return _SERIALIZER_REDACTED_VALUE
+    if _SERIALIZER_UNSAFE_PATH_RE.search(value):
+        return _SERIALIZER_REDACTED_VALUE
+    if _SENSITIVE_VALUE_RE.search(value):
+        return _SERIALIZER_REDACTED_VALUE
+    if _SERIALIZER_SECRET_ASSIGNMENT_RE.search(value):
+        return _SERIALIZER_REDACTED_VALUE
+    return value
+
+
+def _assert_serialized_inventory_payload_safe(payload: object) -> None:
+    encoded = json.dumps(payload, sort_keys=True)
+    if (
+        _SERIALIZER_UNSAFE_PATH_RE.search(encoded)
+        or _SENSITIVE_VALUE_RE.search(encoded)
+        or _SERIALIZER_SECRET_ASSIGNMENT_RE.search(encoded)
+    ):
+        raise ValueError("Inventory snapshot serialization produced unsafe payload.")
+
+
+def _safe_json(
+    value: object,
+    *,
+    parent_key: str = "",
+    parent_sensitive: bool = False,
+) -> object:
+    key_sensitive = parent_sensitive or bool(parent_key and _SENSITIVE_KEY_RE.search(parent_key))
     if isinstance(value, dict):
-        return {str(key): _safe_json(item) for key, item in value.items()}
+        return {
+            _sanitize_serializer_string(str(key), parent_sensitive=parent_sensitive): _safe_json(
+                item,
+                parent_key=str(key),
+                parent_sensitive=key_sensitive,
+            )
+            for key, item in value.items()
+        }
     if isinstance(value, (list, tuple)):
-        return [_safe_json(item) for item in value]
+        return [_safe_json(item, parent_key=parent_key, parent_sensitive=parent_sensitive) for item in value]
     if isinstance(value, Path):
         return value.name
     if isinstance(value, str):
-        return value
+        return _sanitize_serializer_string(
+            value,
+            parent_key=parent_key,
+            parent_sensitive=parent_sensitive,
+        )
     return value
 
 

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/guard/store.py

@@ -86,8 +86,7 @@ from .store_connect import (
 )
 from .store_evidence import (
     EvidenceRecord,
-    evidence_index_statements,
-    evidence_schema_statement,
+    ensure_evidence_schema,
 )
 from .store_evidence import (
     list_evidence as _list_evidence_impl,
@@ -1221,7 +1220,6 @@ class GuardStore:
             connect_request_schema_statement(),
             connect_state_schema_statement(),
             approval_schema_statement(),
-            evidence_schema_statement(),
             supply_chain_bundle_schema_statement(),
             supply_chain_eval_cache_schema_statement(),
             threat_intel_bundle_schema_statement(),
@@ -1230,11 +1228,9 @@ class GuardStore:
         with self._connect() as connection:
             for statement in statements:
                 connection.execute(statement)
+            ensure_evidence_schema(connection)
             if not self._schema_version_applied(connection, version=4):
-                self._ensure_column(connection, "guard_evidence", "action_identity", "text")
                 self._record_schema_version(connection, version=4)
-            for idx_stmt in evidence_index_statements():
-                connection.execute(idx_stmt)
             for idx_stmt in supply_chain_index_statements():
                 connection.execute(idx_stmt)
             for idx_stmt in threat_intel_index_statements():

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/guard/store_evidence.py

@@ -86,6 +86,41 @@ def evidence_index_statements() -> list[str]:
     ]
 
 
+_EVIDENCE_SCHEMA_READY: set[str] = set()
+
+
+def _evidence_schema_cache_key(connection: sqlite3.Connection) -> str:
+    row = connection.execute("pragma database_list").fetchone()
+    if row is None:
+        return ":memory:"
+    file_path = row[2]
+    return str(file_path) if file_path else ":memory:"
+
+
+def ensure_evidence_schema(connection: sqlite3.Connection) -> None:
+    """Create or repair the evidence table, columns, and indexes."""
+    cache_key = _evidence_schema_cache_key(connection)
+    if cache_key in _EVIDENCE_SCHEMA_READY:
+        row = connection.execute(
+            "select 1 from sqlite_master where type='table' and name='guard_evidence' limit 1"
+        ).fetchone()
+        if row is not None:
+            return
+        _EVIDENCE_SCHEMA_READY.discard(cache_key)
+    connection.execute(evidence_schema_statement())
+    rows = connection.execute("pragma table_info(guard_evidence)").fetchall()
+    existing = {str(row[1]) for row in rows}
+    if "action_identity" not in existing:
+        try:
+            connection.execute("alter table guard_evidence add column action_identity text")
+        except sqlite3.OperationalError as error:
+            if "duplicate column name" not in str(error).lower():
+                raise
+    for statement in evidence_index_statements():
+        connection.execute(statement)
+    _EVIDENCE_SCHEMA_READY.add(cache_key)
+
+
 def _row_to_record(row: sqlite3.Row) -> EvidenceRecord:
     try:
         details: dict[str, object] = json.loads(row["details_json"])
@@ -110,6 +145,7 @@ def _row_to_record(row: sqlite3.Row) -> EvidenceRecord:
 
 
 def store_evidence(conn: sqlite3.Connection, record: EvidenceRecord) -> EvidenceRecord:
+    ensure_evidence_schema(conn)
     conn.execute(
         """
         insert or replace into guard_evidence

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.0.577"
+__version__ = "2.0.579"

plugin_scanner-2.0.579/tests/test_guard_aibom_serializer_security.py

@@ -0,0 +1,120 @@
+"""Serializer safety guards for AIBOM inventory snapshots (#196, #197, #209)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from codex_plugin_scanner.cli import main
+from codex_plugin_scanner.guard.inventory_contract import (
+    GuardAgentInventoryFinding,
+    GuardAgentInventoryItem,
+    GuardAgentInventorySnapshot,
+    serialize_inventory_snapshot,
+)
+from codex_plugin_scanner.guard.store import GuardStore
+
+_UNSAFE_PATH_MARKER = "/".join(["", "Users", "agent", "secret.txt"])
+_SECRET_MARKER = "sk-testsecretvalueserializer"
+
+
+def _snapshot_with_metadata(metadata: dict[str, object]) -> GuardAgentInventorySnapshot:
+    return GuardAgentInventorySnapshot(
+        snapshot_id="snap-serializer-security",
+        agent_id="hermes-prod",
+        agent_type="hermes",
+        generated_at="2026-06-10T12:00:00.000Z",
+        items=(
+            GuardAgentInventoryItem(
+                item_id="hermes:skill:serializer-security",
+                item_kind="skill",
+                display_name="Serializer security",
+                source_fingerprint="fp-serializer-security",
+                content_hash="sha256:serializer-security",
+                capability_categories=(),
+                metadata=metadata,
+            ),
+        ),
+    )
+
+
+def test_serialize_inventory_snapshot_redacts_raw_absolute_paths() -> None:
+    snapshot = _snapshot_with_metadata({"localPath": _UNSAFE_PATH_MARKER})
+    payload = serialize_inventory_snapshot(snapshot)
+    encoded = json.dumps(payload, sort_keys=True)
+
+    assert _UNSAFE_PATH_MARKER not in encoded
+    assert payload["items"][0]["metadata"]["localPath"] == "[REDACTED]"
+
+
+def test_serialize_inventory_snapshot_redacts_nested_sensitive_key_values() -> None:
+    snapshot = _snapshot_with_metadata({"token": {"value": "npm_secret_value"}})
+    payload = serialize_inventory_snapshot(snapshot)
+    encoded = json.dumps(payload, sort_keys=True)
+
+    assert "npm_secret_value" not in encoded
+    token_metadata = payload["items"][0]["metadata"]["token"]
+    assert isinstance(token_metadata, dict)
+    assert token_metadata["value"] == "[REDACTED]"
+
+
+def test_serialize_inventory_snapshot_redacts_secret_like_values() -> None:
+    snapshot = _snapshot_with_metadata({"token": _SECRET_MARKER})
+    payload = serialize_inventory_snapshot(snapshot)
+    encoded = json.dumps(payload, sort_keys=True)
+
+    assert _SECRET_MARKER not in encoded
+    assert payload["items"][0]["metadata"]["token"] == "[REDACTED]"
+
+
+def test_serialize_inventory_snapshot_redacts_unsafe_finding_summaries() -> None:
+    snapshot = GuardAgentInventorySnapshot(
+        snapshot_id="snap-serializer-security",
+        agent_id="hermes-prod",
+        agent_type="hermes",
+        generated_at="2026-06-10T12:00:00.000Z",
+        findings=(
+            GuardAgentInventoryFinding(
+                finding_id="finding-1",
+                artifact_id="hermes:skill:serializer-security",
+                check_id="aibom.serializer.unsafe",
+                severity="high",
+                confidence="high",
+                source="metadata",
+                title="Unsafe path",
+                summary=f"Detected {_UNSAFE_PATH_MARKER}",
+            ),
+        ),
+    )
+    payload = serialize_inventory_snapshot(snapshot)
+    encoded = json.dumps(payload, sort_keys=True)
+
+    assert _UNSAFE_PATH_MARKER not in encoded
+    assert payload["findings"][0]["summary"] == "[REDACTED]"
+
+
+def test_guard_doctor_includes_aibom_status_without_raw_paths(tmp_path: Path, capsys) -> None:
+    home_dir = tmp_path / "guard-home"
+    workspace_dir = tmp_path / "workspace"
+    workspace_dir.mkdir()
+    GuardStore(home_dir)
+
+    rc = main(
+        [
+            "guard",
+            "doctor",
+            "--home",
+            str(home_dir),
+            "--workspace",
+            str(workspace_dir),
+            "--json",
+        ]
+    )
+    output = json.loads(capsys.readouterr().out)
+
+    assert rc == 0
+    assert "aibom" in output
+    assert output["aibom"]["snapshot_count"] >= 0
+    encoded = json.dumps(output["aibom"], sort_keys=True)
+    assert str(tmp_path) not in encoded
+    assert _SECRET_MARKER not in encoded

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/tests/test_guard_aibom_symlink.py

@@ -1,9 +1,14 @@
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 
+import pytest
+
 from codex_plugin_scanner.guard.aibom_symlink import (
+    _MAX_SYMLINK_HOPS,
+    _resolve_symlink_chain,
     classify_path_class,
     fingerprint_redacted_path,
     inspect_aibom_source_path,
@@ -204,3 +209,62 @@ def test_inventory_snapshot_emits_findings_for_broken_symlink_sources(tmp_path:
     )
 
     assert any(finding.check_id == "aibom.symlink.broken" for finding in snapshot.findings)
+
+
+def test_resolve_symlink_chain_returns_loop_when_hop_budget_is_exhausted(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(
+        "codex_plugin_scanner.guard.aibom_symlink._MAX_SYMLINK_HOPS",
+        2,
+    )
+    calls = {"count": 0}
+
+    def fake_is_symlink(self: Path) -> bool:
+        return True
+
+    def fake_readlink(_path: str | Path) -> str:
+        calls["count"] += 1
+        return f"sibling-{calls['count']}"
+
+    monkeypatch.setattr(Path, "is_symlink", fake_is_symlink)
+    monkeypatch.setattr(
+        "codex_plugin_scanner.guard.aibom_symlink.os.readlink",
+        fake_readlink,
+    )
+    monkeypatch.setattr(Path, "resolve", lambda self: self)
+
+    resolved, state, _ = _resolve_symlink_chain(
+        Path("/workspace/entry"),
+        safe_roots=(Path("/workspace"),),
+        home_dir=Path("/home"),
+        workspace_dir=Path("/workspace"),
+    )
+
+    assert resolved is None
+    assert state == "loop"
+
+
+def test_max_symlink_hop_budget_is_sixteen() -> None:
+    assert _MAX_SYMLINK_HOPS == 16
+
+
+def test_inspect_oversized_symlink_target_hashes_first_megabyte(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    home = tmp_path / "home"
+    home.mkdir()
+    oversized = workspace / "oversized-target.txt"
+    oversized.write_bytes(b"x" * (1024 * 1024 + 1))
+    link = workspace / "oversized-link"
+    link.symlink_to(oversized)
+
+    inspection = inspect_aibom_source_path(
+        link,
+        safe_roots=(workspace,),
+        home_dir=home,
+        workspace_dir=workspace,
+    )
+
+    assert inspection.validation_state == "valid"
+    assert inspection.target_content_hash

{plugin_scanner-2.0.577 → plugin_scanner-2.0.579}/tests/test_guard_store_migrations.py

@@ -84,6 +84,153 @@ def _clear_oauth_process_caches() -> None:
     guard_store_module._OAUTH_HEALTH_RESULT_PROCESS_CACHE.clear()
 
 
+from codex_plugin_scanner.guard.store import GuardStore
+from codex_plugin_scanner.guard.store_evidence import EvidenceRecord
+
+
+def _incomplete_evidence_table(connection: sqlite3.Connection) -> None:
+    connection.execute(
+        """
+        create table guard_evidence (
+          evidence_id text primary key,
+          action_id text,
+          request_id text,
+          harness text,
+          workspace text,
+          signal_id text,
+          category text,
+          severity text,
+          confidence real,
+          summary text,
+          details_json text,
+          created_at text
+        )
+        """
+    )
+
+
+def test_guard_store_repairs_missing_evidence_table_when_schema_v4_is_applied(tmp_path):
+    guard_home = tmp_path / "guard-home"
+    guard_home.mkdir()
+    database_path = guard_home / "guard.db"
+    with sqlite3.connect(database_path) as connection:
+        connection.execute(
+            "create table schema_migrations (version integer primary key, applied_at text not null)"
+        )
+        connection.execute(
+            "insert into schema_migrations (version, applied_at) values (4, '2026-01-01T00:00:00Z')"
+        )
+        connection.execute(
+            """
+            create table harness_installations (
+              harness text primary key,
+              active integer not null,
+              workspace text,
+              config_path text,
+              metadata_json text not null default '{}',
+              updated_at text not null
+            )
+            """
+        )
+
+    store = GuardStore(guard_home)
+    store.add_evidence(
+        EvidenceRecord(
+            evidence_id="evidence-1",
+            action_id="action-1",
+            request_id="request-1",
+            harness="codex",
+            workspace="/workspace",
+            signal_id="block",
+            category="supply-chain",
+            severity="high",
+            confidence=1.0,
+            summary="blocked package install",
+            action_identity="rule-123",
+        )
+    )
+
+    with sqlite3.connect(database_path) as connection:
+        row = connection.execute(
+            "select action_identity from guard_evidence where evidence_id = 'evidence-1'"
+        ).fetchone()
+
+    assert row is not None
+    assert row[0] == "rule-123"
+
+
+def test_guard_store_repairs_incomplete_evidence_table_missing_action_identity(tmp_path):
+    guard_home = tmp_path / "guard-home"
+    guard_home.mkdir()
+    database_path = guard_home / "guard.db"
+    with sqlite3.connect(database_path) as connection:
+        connection.execute(
+            "create table schema_migrations (version integer primary key, applied_at text not null)"
+        )
+        connection.execute(
+            "insert into schema_migrations (version, applied_at) values (4, '2026-01-01T00:00:00Z')"
+        )
+        _incomplete_evidence_table(connection)
+
+    store = GuardStore(guard_home)
+    store.add_evidence(
+        EvidenceRecord(
+            evidence_id="evidence-legacy",
+            action_id="action-legacy",
+            request_id="request-legacy",
+            harness="codex",
+            workspace="/workspace",
+            signal_id="ask",
+            category="supply-chain",
+            severity="medium",
+            confidence=0.8,
+            summary="package install requires review",
+            action_identity="exception-456",
+        )
+    )
+
+    with sqlite3.connect(database_path) as connection:
+        columns = {
+            str(row[1])
+            for row in connection.execute("pragma table_info(guard_evidence)").fetchall()
+        }
+        row = connection.execute(
+            "select action_identity from guard_evidence where evidence_id = 'evidence-legacy'"
+        ).fetchone()
+
+    assert "action_identity" in columns
+    assert row is not None
+    assert row[0] == "exception-456"
+
+
+def test_add_evidence_self_repairs_dropped_evidence_table(tmp_path):
+    store = GuardStore(tmp_path / "guard-home")
+    with sqlite3.connect(store.path) as connection:
+        connection.execute("drop table guard_evidence")
+
+    store.add_evidence(
+        EvidenceRecord(
+            evidence_id="evidence-repair",
+            action_id="action-repair",
+            request_id="request-repair",
+            harness="codex",
+            workspace="/workspace",
+            signal_id="monitor",
+            category="supply-chain",
+            severity="low",
+            confidence=0.5,
+            summary="monitored package install",
+        )
+    )
+
+    with sqlite3.connect(store.path) as connection:
+        row = connection.execute(
+            "select evidence_id from guard_evidence where evidence_id = 'evidence-repair'"
+        ).fetchone()
+
+    assert row is not None
+
+
 def test_oauth_secret_store_skips_system_keyring_when_macos_default_keychain_is_missing(tmp_path, monkeypatch):
     _install_fake_system_keyring(monkeypatch, usable_macos_keychain=False)
     monkeypatch.setattr(guard_store_module.sys, "platform", "darwin", raising=False)