vouch-protocol 2.0.1__tar.gz → 2.0.2__tar.gz

{vouch_protocol-2.0.1/vouch_protocol.egg-info → vouch_protocol-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vouch-protocol
-Version: 2.0.1
+Version: 2.0.2
 Summary: The Identity & Reputation Standard for AI Agents
 Author-email: Vouch Protocol Contributors <hello@vouch-protocol.com>
 License: Apache License 2.0
@@ -394,7 +394,7 @@ The standalone **`vouch-mcp`** package above ships alongside these in v1.6.2.
 Python, TypeScript, and Go are the full reference implementations. A Rust core with idiomatic Swift, JVM (Java and Kotlin), .NET, and C wrappers shares one codebase, so every language produces byte-identical output, verified against shared test vectors. A WebAssembly build is included for the browser and the edge. See the table further down for status per language.
 
 ### Robots and embodied agents
-A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fourteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), and wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-092.
+A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fifteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), and bystander-consent evidence (a robot binds the basis for capturing people, an explicit token, posted notice, a legitimate interest, or a redaction it applied, to the capture itself by its hash, holding only hashes and never anyone's identifying data, and a bystander can sign consent bound to one capture so it cannot be replayed to another), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-094.
 
 ### Inside your AI tools
 - **Claude Skill**, **OpenAI Custom GPT**, and **Gemini Gem** packages that teach your AI assistant how to add Vouch to your code, running on your own AI subscription.

{vouch_protocol-2.0.1 → vouch_protocol-2.0.2}/README.md

@@ -112,7 +112,7 @@ The standalone **`vouch-mcp`** package above ships alongside these in v1.6.2.
 Python, TypeScript, and Go are the full reference implementations. A Rust core with idiomatic Swift, JVM (Java and Kotlin), .NET, and C wrappers shares one codebase, so every language produces byte-identical output, verified against shared test vectors. A WebAssembly build is included for the browser and the edge. See the table further down for status per language.
 
 ### Robots and embodied agents
-A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fourteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), and wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-092.
+A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fifteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), and bystander-consent evidence (a robot binds the basis for capturing people, an explicit token, posted notice, a legitimate interest, or a redaction it applied, to the capture itself by its hash, holding only hashes and never anyone's identifying data, and a bystander can sign consent bound to one capture so it cannot be replayed to another), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-094.
 
 ### Inside your AI tools
 - **Claude Skill**, **OpenAI Custom GPT**, and **Gemini Gem** packages that teach your AI assistant how to add Vouch to your code, running on your own AI subscription.

{vouch_protocol-2.0.1 → vouch_protocol-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vouch-protocol"
-version = "2.0.1"
+version = "2.0.2"
 description = "The Identity & Reputation Standard for AI Agents"
 readme = "README.md"
 requires-python = ">=3.9"

vouch_protocol-2.0.2/tests/test_robot_consent.py

@@ -0,0 +1,200 @@
+"""Tests for bystander-consent evidence."""
+
+import unittest
+from datetime import datetime, timezone
+
+from vouch import Signer, generate_identity
+from vouch.robotics import (
+    build_consent_evidence,
+    build_consent_token,
+    hash_capture,
+    verify_consent_evidence,
+    verify_consent_token,
+)
+from vouch.robotics.identity import RoboticsError
+
+T0 = datetime(2026, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
+IN_WINDOW = datetime(2026, 1, 1, 0, 5, 0, tzinfo=timezone.utc)
+AFTER = datetime(2026, 1, 1, 2, 0, 0, tzinfo=timezone.utc)
+
+
+def _party(domain):
+    kp = generate_identity(domain=domain)
+    return kp, Signer(private_key=kp.private_key_jwk, did=kp.did)
+
+
+class TestConsentToken(unittest.TestCase):
+    def setUp(self):
+        self.by_kp, self.bystander = _party("person-1.example.com")
+        self.robot_kp, self.robot = _party("robot-a.example.com")
+        self.capture_hash = hash_capture(b"frame-0")
+
+    def _token(self):
+        return build_consent_token(
+            self.bystander,
+            bystander_did=self.by_kp.did,
+            capture_hash=self.capture_hash,
+            robot_did=self.robot_kp.did,
+            valid_seconds=3600,
+            granted_at=T0,
+        )
+
+    def test_token_verifies_for_its_capture(self):
+        ok, subject = verify_consent_token(
+            self._token(),
+            self.by_kp.public_key_jwk,
+            capture_hash=self.capture_hash,
+            robot_did=self.robot_kp.did,
+            now=IN_WINDOW,
+        )
+        self.assertTrue(ok)
+        self.assertEqual(subject["robotDid"], self.robot_kp.did)
+
+    def test_token_rejected_for_other_capture(self):
+        ok, _ = verify_consent_token(
+            self._token(),
+            self.by_kp.public_key_jwk,
+            capture_hash=hash_capture(b"different-frame"),
+            robot_did=self.robot_kp.did,
+            now=IN_WINDOW,
+        )
+        self.assertFalse(ok)
+
+    def test_token_rejected_for_other_robot(self):
+        ok, _ = verify_consent_token(
+            self._token(),
+            self.by_kp.public_key_jwk,
+            capture_hash=self.capture_hash,
+            robot_did="did:web:robot-z.example.com",
+            now=IN_WINDOW,
+        )
+        self.assertFalse(ok)
+
+    def test_token_out_of_window_rejected(self):
+        ok, _ = verify_consent_token(
+            self._token(),
+            self.by_kp.public_key_jwk,
+            capture_hash=self.capture_hash,
+            robot_did=self.robot_kp.did,
+            now=AFTER,
+        )
+        self.assertFalse(ok)
+
+
+class TestConsentEvidence(unittest.TestCase):
+    def setUp(self):
+        self.by_kp, self.bystander = _party("person-1.example.com")
+        self.robot_kp, self.robot = _party("robot-a.example.com")
+        self.robot_did = self.robot_kp.did
+        self.capture = b"frame-0"
+        self.capture_hash = hash_capture(self.capture)
+        self.token = build_consent_token(
+            self.bystander,
+            bystander_did=self.by_kp.did,
+            capture_hash=self.capture_hash,
+            robot_did=self.robot_did,
+            valid_seconds=3600,
+            granted_at=T0,
+        )
+
+    def test_explicit_consent_evidence_verifies(self):
+        ev = build_consent_evidence(
+            self.robot,
+            robot_did=self.robot_did,
+            capture_hash=self.capture_hash,
+            basis="explicit-consent",
+            consent_tokens=[self.token],
+            valid_from=T0,
+        )
+        ok, subject = verify_consent_evidence(
+            ev,
+            self.robot_kp.public_key_jwk,
+            capture=self.capture,
+            consent_tokens=[self.token],
+            bystander_keys={self.by_kp.did: self.by_kp.public_key_jwk},
+            now=IN_WINDOW,
+        )
+        self.assertTrue(ok)
+        self.assertEqual(subject["basis"], "explicit-consent")
+
+    def test_explicit_consent_requires_a_token(self):
+        with self.assertRaises(RoboticsError):
+            build_consent_evidence(
+                self.robot,
+                robot_did=self.robot_did,
+                capture_hash=self.capture_hash,
+                basis="explicit-consent",
+                valid_from=T0,
+            )
+
+    def test_redacted_basis_needs_no_token(self):
+        ev = build_consent_evidence(
+            self.robot,
+            robot_did=self.robot_did,
+            capture_hash=self.capture_hash,
+            basis="redacted",
+            redaction_hash=hash_capture(b"blurred-frame"),
+            valid_from=T0,
+        )
+        ok, subject = verify_consent_evidence(
+            ev, self.robot_kp.public_key_jwk, capture=self.capture
+        )
+        self.assertTrue(ok)
+        self.assertEqual(subject["basis"], "redacted")
+
+    def test_wrong_capture_rejected(self):
+        ev = build_consent_evidence(
+            self.robot,
+            robot_did=self.robot_did,
+            capture_hash=self.capture_hash,
+            basis="posted-notice",
+            valid_from=T0,
+        )
+        ok, _ = verify_consent_evidence(
+            ev, self.robot_kp.public_key_jwk, capture=b"a-different-capture"
+        )
+        self.assertFalse(ok)
+
+    def test_unknown_basis_rejected_at_build(self):
+        with self.assertRaises(RoboticsError):
+            build_consent_evidence(
+                self.robot,
+                robot_did=self.robot_did,
+                capture_hash=self.capture_hash,
+                basis="whatever",
+                valid_from=T0,
+            )
+
+    def test_token_for_another_capture_does_not_satisfy_evidence(self):
+        other_hash = hash_capture(b"other-capture")
+        stray = build_consent_token(
+            self.bystander,
+            bystander_did=self.by_kp.did,
+            capture_hash=other_hash,
+            robot_did=self.robot_did,
+            valid_seconds=3600,
+            granted_at=T0,
+        )
+        ev = build_consent_evidence(
+            self.robot,
+            robot_did=self.robot_did,
+            capture_hash=self.capture_hash,
+            basis="explicit-consent",
+            consent_tokens=[stray],
+            valid_from=T0,
+        )
+        # The stray token is committed, but it is bound to a different capture, so
+        # verifying it against this evidence's capture fails.
+        ok, _ = verify_consent_evidence(
+            ev,
+            self.robot_kp.public_key_jwk,
+            capture=self.capture,
+            consent_tokens=[stray],
+            bystander_keys={self.by_kp.did: self.by_kp.public_key_jwk},
+            now=IN_WINDOW,
+        )
+        self.assertFalse(ok)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vouch_protocol-2.0.1 → vouch_protocol-2.0.2}/vouch/__init__.py

@@ -5,7 +5,7 @@ This package provides cryptographic identity binding for autonomous AI agents,
 enabling verifiable proof of intent and non-repudiation.
 """
 
-__version__ = "2.0.1"
+__version__ = "2.0.2"
 
 # Core signing/verification
 from .signer import Signer, sign

vouch_protocol-2.0.2/vouch/integrations/mlflow.py

@@ -0,0 +1,101 @@
+"""
+Vouch Protocol MLflow Integration.
+
+Sign a model artifact with a Vouch Credential at log or registration time, so a
+registered model carries verifiable lineage: who registered it, on whose
+authority, and a content digest that breaks if the weights are tampered with.
+
+This module has no hard dependency on MLflow. The core helpers operate on a file
+or directory path, so they work with any artifact store. If MLflow is installed,
+log the returned credential as a tag or artifact on the run.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from typing import Any, Dict, Optional, Tuple
+
+from vouch import Signer, Verifier
+
+_RESOURCE_PREFIX = "model:sha256:"
+
+
+def compute_model_digest(path: str) -> str:
+    """Return a SHA-256 hex digest over a model file, or a directory of files.
+
+    For a directory, every file is hashed in sorted relative-path order, and the
+    relative path is mixed in, so the digest is stable and order-independent.
+    """
+    h = hashlib.sha256()
+    if os.path.isdir(path):
+        for root, _dirs, files in os.walk(path):
+            for name in sorted(files):
+                fp = os.path.join(root, name)
+                rel = os.path.relpath(fp, path).replace(os.sep, "/")
+                h.update(rel.encode("utf-8"))
+                h.update(b"\x00")
+                with open(fp, "rb") as f:
+                    for chunk in iter(lambda: f.read(65536), b""):
+                        h.update(chunk)
+    else:
+        with open(path, "rb") as f:
+            for chunk in iter(lambda: f.read(65536), b""):
+                h.update(chunk)
+    return h.hexdigest()
+
+
+def sign_model(
+    signer: Signer,
+    path: str,
+    *,
+    name: Optional[str] = None,
+    parent_credential: Optional[Dict[str, Any]] = None,
+    hybrid: bool = False,
+    valid_seconds: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Issue a Vouch Credential binding the model at ``path`` to the signer.
+
+    The credential's ``resource`` is the model's content digest, so any change to
+    the weights breaks verification.
+
+    Args:
+        signer: The registering principal's Signer.
+        path: Path to the model file or directory.
+        name: Human label for the model. Defaults to the basename of ``path``.
+        parent_credential: Optional parent credential to extend (delegation).
+        hybrid: Issue under the post-quantum hybrid profile when True.
+        valid_seconds: Optional validity window override.
+
+    Returns:
+        A signed Vouch Credential dict. Log it as an MLflow tag or artifact.
+    """
+    digest = compute_model_digest(path)
+    target = name or os.path.basename(os.path.normpath(path)) or "model"
+    intent = {"action": "register", "target": target, "resource": f"{_RESOURCE_PREFIX}{digest}"}
+    issue = signer.sign_hybrid if hybrid else signer.sign
+    return issue(
+        intent=intent,
+        parent_credential=parent_credential,
+        valid_seconds=valid_seconds,
+    )
+
+
+def verify_model(
+    path: str,
+    credential: Dict[str, Any],
+    public_key: Optional[Any] = None,
+) -> Tuple[bool, Optional[Any]]:
+    """Verify a model credential AND that the on-disk content still matches.
+
+    Returns ``(is_valid, passport)``. ``is_valid`` is False if the signature
+    fails OR the recomputed digest does not match the credential's bound digest.
+    """
+    ok, passport = Verifier.verify(credential, public_key=public_key)
+    if not ok:
+        return False, passport
+    intent = (credential.get("credentialSubject") or {}).get("intent") or {}
+    bound = intent.get("resource")
+    if bound != f"{_RESOURCE_PREFIX}{compute_model_digest(path)}":
+        return False, passport
+    return True, passport

vouch_protocol-2.0.2/vouch/integrations/safetensors.py

@@ -0,0 +1,126 @@
+"""
+Vouch Protocol safetensors Integration.
+
+Embed a Vouch Credential in a .safetensors file's existing ``__metadata__``
+header field, with zero changes to the safetensors format or its Rust core.
+
+This is deliberately complementary to OpenSSF Model Signing (OMS). OMS proves an
+artifact is intact and signed by a key. Vouch adds the agent and delegation
+dimension: which principal or pipeline produced the weights, traceable back to an
+accountable human. The credential is bound to a SHA-256 of the tensor data
+buffer, so any change to the weights breaks verification. Standard loaders
+(including Hugging Face) ignore the extra metadata key, so signed files load
+normally.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import struct
+from typing import Any, Dict, Optional, Tuple
+
+from vouch import Signer, Verifier
+
+_META_KEY = "vouch_credential"
+_RESOURCE_PREFIX = "model:safetensors:sha256:"
+
+
+def _read(path: str) -> Tuple[Dict[str, Any], bytes]:
+    """Return (header_dict, tensor_data_bytes) from a safetensors file."""
+    with open(path, "rb") as f:
+        header_len = struct.unpack("<Q", f.read(8))[0]
+        header = json.loads(f.read(header_len).decode("utf-8"))
+        data = f.read()
+    return header, data
+
+
+def _write(path: str, header: Dict[str, Any], data: bytes) -> None:
+    """Write a safetensors file from a header dict and the tensor data buffer."""
+    header_bytes = json.dumps(header, separators=(",", ":")).encode("utf-8")
+    with open(path, "wb") as f:
+        f.write(struct.pack("<Q", len(header_bytes)))
+        f.write(header_bytes)
+        f.write(data)
+
+
+def tensor_data_digest(path: str) -> str:
+    """Return the SHA-256 hex digest of the tensor data buffer (excludes header)."""
+    _header, data = _read(path)
+    return hashlib.sha256(data).hexdigest()
+
+
+def sign_safetensors(
+    signer: Signer,
+    path: str,
+    *,
+    out_path: Optional[str] = None,
+    name: Optional[str] = None,
+    parent_credential: Optional[Dict[str, Any]] = None,
+    hybrid: bool = False,
+    valid_seconds: Optional[int] = None,
+) -> Dict[str, Any]:
+    """Embed a Vouch Credential in a safetensors file's ``__metadata__``.
+
+    The credential binds to a digest of the tensor data buffer. The header gains
+    one string key; the tensor bytes are untouched.
+
+    Args:
+        signer: The producing principal's Signer.
+        path: Path to the input .safetensors file.
+        out_path: Where to write the signed file. Defaults to ``path`` (in place).
+        name: Human label for the model.
+        parent_credential: Optional parent credential to extend (delegation).
+        hybrid: Issue under the post-quantum hybrid profile when True.
+        valid_seconds: Optional validity window override.
+
+    Returns:
+        The signed Vouch Credential dict (also embedded in the file).
+    """
+    header, data = _read(path)
+    digest = hashlib.sha256(data).hexdigest()
+    intent = {
+        "action": "register",
+        "target": name or "safetensors-model",
+        "resource": f"{_RESOURCE_PREFIX}{digest}",
+    }
+    issue = signer.sign_hybrid if hybrid else signer.sign
+    credential = issue(
+        intent=intent,
+        parent_credential=parent_credential,
+        valid_seconds=valid_seconds,
+    )
+    metadata = dict(header.get("__metadata__") or {})
+    metadata[_META_KEY] = json.dumps(credential, separators=(",", ":"))
+    header["__metadata__"] = metadata
+    _write(out_path or path, header, data)
+    return credential
+
+
+def read_embedded_credential(path: str) -> Optional[Dict[str, Any]]:
+    """Return the embedded Vouch Credential, or None if the file is unsigned."""
+    header, _data = _read(path)
+    raw = (header.get("__metadata__") or {}).get(_META_KEY)
+    return json.loads(raw) if raw else None
+
+
+def verify_safetensors(
+    path: str,
+    public_key: Optional[Any] = None,
+) -> Tuple[bool, Optional[Any]]:
+    """Verify a signed safetensors file: signature AND tensor-data integrity.
+
+    Returns ``(is_valid, passport)``. ``is_valid`` is False if the file is
+    unsigned, the signature fails, or the tensor data no longer matches the
+    bound digest.
+    """
+    credential = read_embedded_credential(path)
+    if not credential:
+        return False, None
+    ok, passport = Verifier.verify(credential, public_key=public_key)
+    if not ok:
+        return False, passport
+    bound = (credential.get("credentialSubject") or {}).get("intent", {}).get("resource")
+    if bound != f"{_RESOURCE_PREFIX}{tensor_data_digest(path)}":
+        return False, passport
+    return True, passport

{vouch_protocol-2.0.1 → vouch_protocol-2.0.2}/vouch/robotics/__init__.py

@@ -24,6 +24,7 @@ robots and embodied agents:
   - access: bounded, revocable robot access to physical infrastructure resources.
   - fusion: signed provenance binding a fused world model to its input frames.
   - wear: signed wear and degradation attestation with capability auto-attenuation.
+  - consent: bystander-consent evidence binding a consent basis to a robot capture.
 """
 
 from .capability import (
@@ -170,6 +171,16 @@ from .wear import (
     verify_wear_attestation,
     verify_wear_chain,
 )
+from .consent import (
+    CONSENT_BASES,
+    CONSENT_EVIDENCE_TYPE,
+    CONSENT_TOKEN_TYPE,
+    build_consent_evidence,
+    build_consent_token,
+    hash_capture,
+    verify_consent_evidence,
+    verify_consent_token,
+)
 
 __all__ = [
     # identity
@@ -287,6 +298,15 @@ __all__ = [
     "verify_wear_attestation",
     "verify_wear_chain",
     "attenuate_for_wear",
+    # bystander consent (consent basis bound to a robot capture, privacy-preserving)
+    "CONSENT_EVIDENCE_TYPE",
+    "CONSENT_TOKEN_TYPE",
+    "CONSENT_BASES",
+    "hash_capture",
+    "build_consent_token",
+    "verify_consent_token",
+    "build_consent_evidence",
+    "verify_consent_evidence",
     # safety record (incident/near-miss ledger + portable record)
     "SafetyEventLog",
     "verify_safety_log",