plugin-scanner 2.0.727__tar.gz → 2.0.729__tar.gz

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.727
+Version: 2.0.729
 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.727 → plugin_scanner-2.0.729}/pyproject.toml

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

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.727"
+version = "2.0.729"
 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.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/guard/adapters/mcp_servers.py

@@ -34,6 +34,14 @@ def is_guard_mcp_companion_name(name: str) -> bool:
     return name.startswith(GUARD_MCP_COMPANION_PREFIX)
 
 
+def is_verified_guard_mcp_companion(
+    name: str,
+    command: str | None,
+    args: tuple[str, ...],
+) -> bool:
+    return is_guard_mcp_companion_name(name) and is_guard_proxy_command(command, args)
+
+
 _GUARD_PROXY_COMMANDS = frozenset(
     {
         "codex-mcp-proxy",
@@ -165,7 +173,7 @@ def proxy_process_env(server_env: dict[str, str]) -> dict[str, str]:
 def _managed_stdio_server(artifact: GuardArtifact) -> ManagedMcpServer | None:
     if artifact.artifact_type != "mcp_server":
         return None
-    if is_guard_mcp_companion_name(artifact.name):
+    if is_verified_guard_mcp_companion(artifact.name, artifact.command, artifact.args):
         return None
     if _bool_metadata(artifact.metadata.get("guard_managed_proxy"), default=False):
         return None
@@ -282,6 +290,7 @@ __all__ = [
     "ManagedMcpServer",
     "is_guard_mcp_companion_name",
     "is_guard_proxy_command",
+    "is_verified_guard_mcp_companion",
     "managed_stdio_servers",
     "proxy_cli_args",
     "proxy_process_env",

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/guard/adapters/opencode_artifacts.py

@@ -10,7 +10,7 @@ from pathlib import Path
 from ..models import GuardArtifact
 from ..runtime.mcp_skill_firewall import enrich_artifact_with_mcp_skill_firewall
 from .base import HarnessContext
-from .mcp_servers import is_guard_mcp_companion_name, is_guard_proxy_command
+from .mcp_servers import is_guard_proxy_command, is_verified_guard_mcp_companion
 
 CONFIG_FILENAMES = ("opencode.json", "opencode.jsonc")
 PLUGIN_SUFFIXES = {".js", ".ts", ".mjs", ".cjs"}
@@ -246,9 +246,9 @@ def _append_mcp_artifacts(
     for name, server_config in mcp_config.items():
         if not isinstance(name, str) or not isinstance(server_config, dict):
             continue
-        if is_guard_mcp_companion_name(name):
-            continue
         command, args = _command_parts(server_config)
+        if is_verified_guard_mcp_companion(name, command, args):
+            continue
         transport = server_config.get("type") if isinstance(server_config.get("type"), str) else None
         url = server_config.get("url") if isinstance(server_config.get("url"), str) else None
         environment = server_config.get("environment")

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/guard/aibom_cli.py

@@ -47,6 +47,7 @@ def collect_aibom_snapshots(
     *,
     generated_at: str,
     options: AibomCliOptions | None = None,
+    trust_attestation_context: dict[str, object] | None = None,
 ) -> tuple[GuardAgentInventorySnapshot, ...]:
     resolved = options or AibomCliOptions()
     snapshots: list[GuardAgentInventorySnapshot] = []
@@ -70,11 +71,31 @@ def collect_aibom_snapshots(
                 cisco_runs=cisco_runs,
                 include_symlinks=resolved.include_symlinks,
                 follow_unsafe_symlinks=resolved.follow_unsafe_symlinks,
+                trust_attestation_context=trust_attestation_context,
             )
         )
     return tuple(snapshots)
 
 
+def _resolve_trust_attestation_context(store: GuardStore) -> dict[str, object]:
+    from .runtime.trust_attestation import (
+        resolve_guard_oauth_trust_attestation_signing_config,
+        resolve_trust_attestation_signing_config,
+        trust_attestation_v2_enabled,
+    )
+
+    oauth_credentials = store.get_oauth_local_credentials(allow_primary=True)
+    signing_config = resolve_guard_oauth_trust_attestation_signing_config(oauth_credentials)
+    if signing_config is None:
+        signing_config = resolve_trust_attestation_signing_config()
+    enable_v2 = trust_attestation_v2_enabled()
+    return {
+        "deviceId": store.get_or_create_installation_id() if enable_v2 else None,
+        "signingConfig": signing_config,
+        "workspaceId": store.get_cloud_workspace_id() if enable_v2 else None,
+    }
+
+
 def build_inventory_json_payload(
     store: GuardStore,
     context: HarnessContext,
@@ -82,7 +103,12 @@ def build_inventory_json_payload(
     generated_at: str,
     options: AibomCliOptions | None = None,
 ) -> dict[str, object]:
-    snapshots = collect_aibom_snapshots(context, generated_at=generated_at, options=options)
+    snapshots = collect_aibom_snapshots(
+        context,
+        generated_at=generated_at,
+        options=options,
+        trust_attestation_context=_resolve_trust_attestation_context(store),
+    )
     metadata_by_artifact = _metadata_lookup_from_snapshots(snapshots)
     items: list[dict[str, object]] = []
     for item in store.list_inventory():
@@ -109,7 +135,12 @@ def build_aibom_status_payload(
     generated_at: str,
     options: AibomCliOptions | None = None,
 ) -> dict[str, object]:
-    snapshots = collect_aibom_snapshots(context, generated_at=generated_at, options=options)
+    snapshots = collect_aibom_snapshots(
+        context,
+        generated_at=generated_at,
+        options=options,
+        trust_attestation_context=_resolve_trust_attestation_context(store),
+    )
     sync_summary = _sync_summary(store)
     layer_summary, trust_summary, drift_summary = summarize_aibom_layers(
         snapshots,
@@ -136,7 +167,12 @@ def build_aibom_export_payload(
     options: AibomCliOptions | None = None,
     export_format: AibomExportFormat = "json",
 ) -> dict[str, object]:
-    snapshots = collect_aibom_snapshots(context, generated_at=generated_at, options=options)
+    snapshots = collect_aibom_snapshots(
+        context,
+        generated_at=generated_at,
+        options=options,
+        trust_attestation_context=_resolve_trust_attestation_context(store),
+    )
     serialized_snapshots = [serialize_inventory_snapshot(snapshot) for snapshot in snapshots]
     artifacts = _artifact_rows_from_store(store, snapshots)
     layer_summary, trust_summary, drift_summary = summarize_aibom_layers(
@@ -300,10 +336,12 @@ def sync_aibom_snapshots(
         raise GuardSyncNotConfiguredError("Guard Cloud workspace is not configured. Run `hol-guard connect` first.")
 
     resolved_options = options or _AIBOM_CLOUD_SYNC_OPTIONS
+    trust_attestation_context = _resolve_trust_attestation_context(store)
     snapshots = collect_aibom_snapshots(
         context,
         generated_at=generated_at,
         options=resolved_options,
+        trust_attestation_context=trust_attestation_context,
     )
     if not snapshots:
         synced_at = generated_at
@@ -323,6 +361,11 @@ def sync_aibom_snapshots(
         _inventory_snapshot_event(
             snapshot=snapshot,
             workspace_id=workspace_id,
+            device_id=(
+                str(trust_attestation_context["deviceId"])
+                if isinstance(trust_attestation_context.get("deviceId"), str)
+                else None
+            ),
             generated_at=generated_at,
         )
         for snapshot in snapshots
@@ -575,6 +618,7 @@ def _inventory_snapshot_event(
     *,
     snapshot: GuardAgentInventorySnapshot,
     workspace_id: str,
+    device_id: str | None,
     generated_at: str,
 ) -> dict[str, object]:
     event_id = str(uuid.uuid4())
@@ -585,6 +629,7 @@ def _inventory_snapshot_event(
         "occurredAt": generated_at,
         "source": "edge",
         "workspaceId": workspace_id,
+        "deviceId": device_id,
         "payload": {"snapshot": serialize_inventory_snapshot(snapshot)},
     }
 

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/guard/inventory_contract.py

@@ -6,6 +6,7 @@ import hashlib
 import ipaddress
 import json
 import re
+from collections.abc import Mapping
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
@@ -368,6 +369,7 @@ def inventory_snapshot_from_detection(
     cisco_runs: tuple[object, ...] = (),
     include_symlinks: bool = True,
     follow_unsafe_symlinks: bool = False,
+    trust_attestation_context: Mapping[str, object] | None = None,
 ) -> GuardAgentInventorySnapshot:
     from .aibom_detection import discover_shared_workspace_aibom_artifacts
 
@@ -395,6 +397,7 @@ def inventory_snapshot_from_detection(
             cisco_runs=cisco_runs,
             include_symlinks=include_symlinks,
             follow_unsafe_symlinks=follow_unsafe_symlinks,
+            trust_attestation_context=trust_attestation_context,
         )
         items.append(item)
         items.extend(
@@ -556,6 +559,7 @@ def _item_from_artifact(
     cisco_runs: tuple[object, ...] = (),
     include_symlinks: bool = True,
     follow_unsafe_symlinks: bool = False,
+    trust_attestation_context: Mapping[str, object] | None = None,
 ) -> GuardAgentInventoryItem:
     artifact_id = str(getattr(artifact, "artifact_id", "artifact"))
     artifact_type = str(getattr(artifact, "artifact_type", "unknown"))
@@ -589,7 +593,22 @@ def _item_from_artifact(
         }
     )
     content_hash = _resolve_item_content_hash(safe_metadata, semantic_text)
-    from .runtime.trust_attestation import apply_trust_attestation_metadata
+    from .runtime.trust_attestation import (
+        GuardTrustAttestationSigningConfig,
+        apply_trust_attestation_metadata,
+    )
+
+    workspace_id = None
+    device_id = None
+    signing_config = None
+    if isinstance(trust_attestation_context, Mapping):
+        raw_workspace_id = trust_attestation_context.get("workspaceId")
+        workspace_id = raw_workspace_id if isinstance(raw_workspace_id, str) and raw_workspace_id else None
+        raw_device_id = trust_attestation_context.get("deviceId")
+        device_id = raw_device_id if isinstance(raw_device_id, str) and raw_device_id else None
+        raw_signing_config = trust_attestation_context.get("signingConfig")
+        if isinstance(raw_signing_config, GuardTrustAttestationSigningConfig):
+            signing_config = raw_signing_config
 
     safe_metadata = apply_trust_attestation_metadata(
         safe_metadata,
@@ -597,6 +616,9 @@ def _item_from_artifact(
         item_id=artifact_id,
         item_kind=item_kind,
         content_hash=content_hash,
+        workspace_id=workspace_id,
+        device_id=device_id,
+        signing_config=signing_config,
     )
     publisher = getattr(artifact, "publisher", None)
     publisher_text = publisher if isinstance(publisher, str) else None

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/guard/runtime/trust_attestation.py

@@ -9,17 +9,23 @@ from dataclasses import dataclass
 
 from cryptography.exceptions import InvalidSignature
 from cryptography.hazmat.primitives import hashes, serialization
-from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives.asymmetric import ec, padding
+from cryptography.hazmat.primitives.asymmetric.ec import EllipticCurvePrivateKey, EllipticCurvePublicKey
 from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey, RSAPublicKey
 
 GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION = "guard-aibom-trust-attestation.v1"
+GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION_V2 = "guard-aibom-trust-attestation.v2"
 GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM = "rsa-pss-sha256"
+GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256 = "ecdsa-p256-sha256"
+_TRUTHY_ENV_VALUES = frozenset({"1", "true", "yes", "on"})
 
 
 @dataclass(frozen=True, slots=True)
 class GuardTrustAttestationSigningConfig:
     active_key_id: str
     private_key_pem: str
+    public_jwk_thumbprint: str | None = None
+    signature_algorithm: str = GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM
 
 
 @dataclass(frozen=True, slots=True)
@@ -27,6 +33,7 @@ class GuardTrustAttestationVerificationKey:
     key_id: str
     public_key_pem: str
     fingerprint_sha256: str
+    public_jwk_thumbprint: str | None = None
 
 
 def canonical_trust_attestation_payload(payload: Mapping[str, object]) -> bytes:
@@ -68,9 +75,36 @@ def build_trust_attestation_verification_key(
         key_id=config.active_key_id,
         public_key_pem=public_key_pem,
         fingerprint_sha256=_public_key_fingerprint(public_key_pem),
+        public_jwk_thumbprint=config.public_jwk_thumbprint,
     )
 
 
+def resolve_guard_oauth_trust_attestation_signing_config(
+    credentials: Mapping[str, object] | None,
+) -> GuardTrustAttestationSigningConfig | None:
+    if not isinstance(credentials, Mapping):
+        return None
+    private_key_pem = _normalize_pem(_sanitize_object_string(credentials.get("dpop_private_key_pem")))
+    public_jwk_thumbprint = _sanitize_object_string(credentials.get("dpop_public_jwk_thumbprint")) or None
+    if not private_key_pem or public_jwk_thumbprint is None:
+        return None
+    try:
+        _load_private_key(private_key_pem)
+    except ValueError:
+        return None
+    return GuardTrustAttestationSigningConfig(
+        active_key_id=public_jwk_thumbprint,
+        private_key_pem=private_key_pem,
+        public_jwk_thumbprint=public_jwk_thumbprint,
+        signature_algorithm=GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256,
+    )
+
+
+def trust_attestation_v2_enabled(environ: Mapping[str, str] | None = None) -> bool:
+    env = environ or os.environ
+    return _sanitize_env(env.get("GUARD_AIBOM_TRUST_ATTESTATION_V2")).lower() in _TRUTHY_ENV_VALUES
+
+
 def build_trust_attestation_payload(
     *,
     agent_id: str,
@@ -80,11 +114,18 @@ def build_trust_attestation_payload(
     captured_at: str,
     evidence_hash: str,
     scope: str,
+    workspace_id: str | None = None,
+    device_id: str | None = None,
     layer_id: str | None = None,
     layer_type: str | None = None,
 ) -> dict[str, object]:
+    payload_version = (
+        GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION_V2
+        if workspace_id is not None or device_id is not None
+        else GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION
+    )
     payload: dict[str, object] = {
-        "payloadVersion": GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION,
+        "payloadVersion": payload_version,
         "agentId": agent_id,
         "itemId": item_id,
         "itemKind": item_kind,
@@ -93,6 +134,10 @@ def build_trust_attestation_payload(
         "evidenceHash": evidence_hash,
         "scope": scope,
     }
+    if workspace_id is not None:
+        payload["workspaceId"] = workspace_id
+    if device_id is not None:
+        payload["deviceId"] = device_id
     if layer_id is not None:
         payload["layerId"] = layer_id
     if layer_type is not None:
@@ -107,8 +152,11 @@ def apply_trust_attestation_metadata(
     item_id: str,
     item_kind: str,
     content_hash: str,
+    workspace_id: str | None = None,
+    device_id: str | None = None,
+    signing_config: GuardTrustAttestationSigningConfig | None = None,
 ) -> dict[str, object]:
-    config = resolve_trust_attestation_signing_config()
+    config = signing_config or resolve_trust_attestation_signing_config()
     if config is None:
         return metadata
 
@@ -131,6 +179,8 @@ def apply_trust_attestation_metadata(
                     captured_at=captured_at,
                     evidence_hash=evidence_hash,
                     scope="trust_resolution",
+                    workspace_id=workspace_id,
+                    device_id=device_id,
                 ),
                 config=config,
                 signed_at=captured_at,
@@ -172,6 +222,8 @@ def apply_trust_attestation_metadata(
                         captured_at=captured_at,
                         evidence_hash=evidence_hash,
                         scope="trust_layer",
+                        workspace_id=workspace_id,
+                        device_id=device_id,
                         layer_id=layer_id,
                         layer_type=layer_type,
                     ),
@@ -194,24 +246,30 @@ def sign_trust_attestation(
 ) -> dict[str, object]:
     private_key = _load_private_key(config.private_key_pem)
     canonical_payload = canonical_trust_attestation_payload(_payload_with_signed_at(payload, signed_at))
-    signature = private_key.sign(
-        canonical_payload,
-        padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
-        hashes.SHA256(),
+    signature = _sign_payload(
+        private_key=private_key,
+        canonical_payload=canonical_payload,
+        signature_algorithm=config.signature_algorithm,
     )
     verification_key = _verification_key_from_private_key(
         private_key,
         key_id=config.active_key_id,
+        public_jwk_thumbprint=config.public_jwk_thumbprint,
     )
     return {
-        "payloadVersion": GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION,
+        "payloadVersion": str(payload.get("payloadVersion") or GUARD_TRUST_ATTESTATION_PAYLOAD_VERSION),
         "payloadHash": hashlib.sha256(canonical_payload).hexdigest(),
         "signature": base64.b64encode(signature).decode("ascii"),
-        "signatureAlgorithm": GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM,
+        "signatureAlgorithm": config.signature_algorithm,
         "signedAt": signed_at,
         "keyId": verification_key.key_id,
         "publicKeyPem": verification_key.public_key_pem,
         "fingerprintSha256": verification_key.fingerprint_sha256,
+        **(
+            {"publicJwkThumbprint": verification_key.public_jwk_thumbprint}
+            if verification_key.public_jwk_thumbprint is not None
+            else {}
+        ),
     }
 
 
@@ -226,6 +284,7 @@ def verify_trust_attestation(
     raw_key_id = envelope.get("keyId")
     raw_public_key_pem = envelope.get("publicKeyPem")
     raw_fingerprint_sha256 = envelope.get("fingerprintSha256")
+    raw_public_jwk_thumbprint = envelope.get("publicJwkThumbprint")
     raw_signature = envelope.get("signature")
     if not isinstance(raw_payload_hash, str) or not raw_payload_hash:
         raise ValueError("Trust attestation envelope is incomplete")
@@ -244,8 +303,12 @@ def verify_trust_attestation(
     key_id: str = raw_key_id
     public_key_pem: str = raw_public_key_pem
     fingerprint_sha256: str = raw_fingerprint_sha256
+    public_jwk_thumbprint = raw_public_jwk_thumbprint if isinstance(raw_public_jwk_thumbprint, str) else None
     signature: str = raw_signature
-    if signature_algorithm != GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM:
+    if signature_algorithm not in {
+        GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM,
+        GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256,
+    }:
         raise ValueError("Unsupported trust attestation signature algorithm")
     canonical_payload = canonical_trust_attestation_payload(_payload_with_signed_at(payload, envelope.get("signedAt")))
     if hashlib.sha256(canonical_payload).hexdigest() != payload_hash:
@@ -256,34 +319,36 @@ def verify_trust_attestation(
         trusted_key.key_id == key_id
         and trusted_key.fingerprint_sha256 == fingerprint_sha256
         and _normalize_pem(trusted_key.public_key_pem) == _normalize_pem(public_key_pem)
+        and (public_jwk_thumbprint is None or trusted_key.public_jwk_thumbprint == public_jwk_thumbprint)
         for trusted_key in trusted_keys
     ):
         raise ValueError("Trust attestation key is not trusted")
     public_key = serialization.load_pem_public_key(public_key_pem.encode("utf-8"))
-    if not isinstance(public_key, RSAPublicKey):
-        raise ValueError("Trust attestation public key must be RSA")
+    if not isinstance(public_key, (RSAPublicKey, EllipticCurvePublicKey)):
+        raise ValueError("Trust attestation public key must be RSA or EC")
     try:
-        public_key.verify(
-            base64.b64decode(signature),
-            canonical_payload,
-            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
-            hashes.SHA256(),
+        _verify_signature(
+            public_key=public_key,
+            canonical_payload=canonical_payload,
+            signature=base64.b64decode(signature),
+            signature_algorithm=signature_algorithm,
         )
     except InvalidSignature as exc:
         raise ValueError("Trust attestation signature verification failed") from exc
 
 
-def _load_private_key(private_key_pem: str) -> RSAPrivateKey:
+def _load_private_key(private_key_pem: str) -> RSAPrivateKey | EllipticCurvePrivateKey:
     private_key = serialization.load_pem_private_key(private_key_pem.encode("utf-8"), password=None)
-    if not isinstance(private_key, RSAPrivateKey):
-        raise ValueError("Trust attestation private key must be RSA")
+    if not isinstance(private_key, (RSAPrivateKey, EllipticCurvePrivateKey)):
+        raise ValueError("Trust attestation private key must be RSA or EC")
     return private_key
 
 
 def _verification_key_from_private_key(
-    private_key: RSAPrivateKey,
+    private_key: RSAPrivateKey | EllipticCurvePrivateKey,
     *,
     key_id: str,
+    public_jwk_thumbprint: str | None = None,
 ) -> GuardTrustAttestationVerificationKey:
     public_key_pem = (
         private_key.public_key()
@@ -298,9 +363,60 @@ def _verification_key_from_private_key(
         key_id=key_id,
         public_key_pem=public_key_pem,
         fingerprint_sha256=_public_key_fingerprint(public_key_pem),
+        public_jwk_thumbprint=public_jwk_thumbprint,
     )
 
 
+def _sign_payload(
+    *,
+    private_key: RSAPrivateKey | EllipticCurvePrivateKey,
+    canonical_payload: bytes,
+    signature_algorithm: str,
+) -> bytes:
+    if signature_algorithm == GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM:
+        if not isinstance(private_key, RSAPrivateKey):
+            raise ValueError("Trust attestation private key must be RSA")
+        return private_key.sign(
+            canonical_payload,
+            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
+            hashes.SHA256(),
+        )
+    if signature_algorithm == GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256:
+        if not isinstance(private_key, EllipticCurvePrivateKey):
+            raise ValueError("Trust attestation private key must be EC")
+        if not isinstance(private_key.curve, ec.SECP256R1):
+            raise ValueError("Trust attestation EC private key must use P-256")
+        return private_key.sign(canonical_payload, ec.ECDSA(hashes.SHA256()))
+    raise ValueError("Unsupported trust attestation signature algorithm")
+
+
+def _verify_signature(
+    *,
+    public_key: RSAPublicKey | EllipticCurvePublicKey,
+    canonical_payload: bytes,
+    signature: bytes,
+    signature_algorithm: str,
+) -> None:
+    if signature_algorithm == GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM:
+        if not isinstance(public_key, RSAPublicKey):
+            raise ValueError("Trust attestation public key must be RSA")
+        public_key.verify(
+            signature,
+            canonical_payload,
+            padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
+            hashes.SHA256(),
+        )
+        return
+    if signature_algorithm == GUARD_TRUST_ATTESTATION_SIGNATURE_ALGORITHM_ECDSA_P256:
+        if not isinstance(public_key, EllipticCurvePublicKey):
+            raise ValueError("Trust attestation public key must be EC")
+        if not isinstance(public_key.curve, ec.SECP256R1):
+            raise ValueError("Trust attestation EC public key must use P-256")
+        public_key.verify(signature, canonical_payload, ec.ECDSA(hashes.SHA256()))
+        return
+    raise ValueError("Unsupported trust attestation signature algorithm")
+
+
 def _payload_with_signed_at(
     payload: Mapping[str, object],
     signed_at: object,
@@ -320,5 +436,9 @@ def _sanitize_env(value: str | None) -> str:
     return value.replace("\\n", "\n").replace("\r\n", "\n").strip().strip("'\"") if isinstance(value, str) else ""
 
 
+def _sanitize_object_string(value: object) -> str:
+    return value.strip() if isinstance(value, str) else ""
+
+
 def _normalize_pem(value: str) -> str:
     return value.replace("\r\n", "\n").strip()

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.727 → plugin_scanner-2.0.729}/tests/test_guard_aibom_cli.py

@@ -12,7 +12,7 @@ from codex_plugin_scanner.guard import aibom_cli
 from codex_plugin_scanner.guard.adapters.base import HarnessContext
 from codex_plugin_scanner.guard.cli import commands_dispatch_records as dispatch
 from codex_plugin_scanner.guard.inventory_cisco import CiscoInventoryRun
-from codex_plugin_scanner.guard.inventory_contract import inventory_snapshot_from_detection
+from codex_plugin_scanner.guard.inventory_contract import GuardAgentInventorySnapshot, inventory_snapshot_from_detection
 from codex_plugin_scanner.guard.models import GuardArtifact, HarnessDetection
 from codex_plugin_scanner.guard.store import GuardStore
 
@@ -291,6 +291,52 @@ def test_sync_aibom_snapshots_if_due_retries_empty_sync_after_interval(
     assert summary.get("synced") is True
 
 
+def test_inventory_snapshot_event_includes_device_id() -> None:
+    snapshot = GuardAgentInventorySnapshot(
+        snapshot_id='snapshot-aibom-1',
+        agent_id='codex:local',
+        agent_type='codex',
+        generated_at='2026-06-10T12:00:00+00:00',
+        runtime_version='test',
+    )
+
+    event = aibom_cli._inventory_snapshot_event(
+        snapshot=snapshot,
+        workspace_id='workspace-1',
+        device_id='device-1',
+        generated_at='2026-06-10T12:00:00+00:00',
+    )
+
+    assert event['deviceId'] == 'device-1'
+
+
+def test_resolve_trust_attestation_context_defaults_to_v1(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    store = GuardStore(tmp_path / 'guard')
+    monkeypatch.setattr(store, 'get_cloud_workspace_id', lambda: 'workspace-1')
+    monkeypatch.setattr(store, 'get_or_create_installation_id', lambda: 'device-1')
+    monkeypatch.delenv('GUARD_AIBOM_TRUST_ATTESTATION_V2', raising=False)
+
+    context = aibom_cli._resolve_trust_attestation_context(store)
+
+    assert context['workspaceId'] is None
+    assert context['deviceId'] is None
+
+
+def test_resolve_trust_attestation_context_includes_workspace_device_for_v2(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    store = GuardStore(tmp_path / 'guard')
+    monkeypatch.setattr(store, 'get_cloud_workspace_id', lambda: 'workspace-1')
+    monkeypatch.setattr(store, 'get_or_create_installation_id', lambda: 'device-1')
+    monkeypatch.setenv('GUARD_AIBOM_TRUST_ATTESTATION_V2', '1')
+
+    context = aibom_cli._resolve_trust_attestation_context(store)
+
+    assert context['workspaceId'] == 'workspace-1'
+    assert context['deviceId'] == 'device-1'
+
+
 def test_sync_aibom_snapshots_404_backoff_isolated_from_guard_events_summary(
     tmp_path: Path,
     monkeypatch,
@@ -474,6 +520,10 @@ def test_sync_aibom_snapshots_uses_cloud_sync_cisco_defaults(
     assert options.cisco_skill_scan == "auto"
     assert options.cisco_mcp_scan == "auto"
     assert options.cisco_timeout_seconds == 30.0
+    trust_attestation_context = collect_kwargs["trust_attestation_context"]
+    assert isinstance(trust_attestation_context, dict)
+    assert trust_attestation_context["deviceId"] is None
+    assert trust_attestation_context["workspaceId"] is None
 
 
 def test_guard_aibom_sync_command_uses_cloud_sync_cisco_defaults(