vouch-protocol 2.2.0__tar.gz → 3.0.0__tar.gz

{vouch_protocol-2.2.0/vouch_protocol.egg-info → vouch_protocol-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vouch-protocol
-Version: 2.2.0
+Version: 3.0.0
 Summary: The Identity & Reputation Standard for AI Agents
 Author-email: Vouch Protocol Contributors <hello@vouch-protocol.com>
 License: Apache License 2.0

{vouch_protocol-2.2.0 → vouch_protocol-3.0.0}/pyproject.toml

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

{vouch_protocol-2.2.0 → vouch_protocol-3.0.0}/tests/test_authority_state.py

@@ -37,6 +37,7 @@ from vouch.status_list import (
 from vouch.heartbeat import HeartbeatRequest, HeartbeatSession, HeartbeatValidator
 from vouch.vc import build_session_voucher
 from vouch.trust_check import verify_agent_call
+from _heartbeat_keys import resolve, signed_session  # noqa: E402
 
 
 AUTHORITY_DID = "did:web:treasury.example.com"
@@ -312,7 +313,7 @@ def test_session_voucher_carries_epoch():
 
 
 def test_heartbeat_request_roundtrips_epoch():
-    session = HeartbeatSession(subject_did="did:web:agent.example.com", authority_epoch=6)
+    session = signed_session("did:web:agent.example.com", authority_epoch=6)
     req = session.build_request()
     assert req.authority_epoch == 6
     d = req.to_dict()
@@ -322,8 +323,8 @@ def test_heartbeat_request_roundtrips_epoch():
 
 
 def test_heartbeat_validator_tracks_highest_epoch_and_mints_voucher():
-    validator = HeartbeatValidator(validator_did="did:web:v.example.com")
-    session = HeartbeatSession(subject_did="did:web:agent.example.com", authority_epoch=2)
+    validator = HeartbeatValidator(key_resolver=resolve, validator_did="did:web:v.example.com")
+    session = signed_session("did:web:agent.example.com", authority_epoch=2)
     res = validator.validate(session.build_request().to_dict())
     assert res.ok
     assert res.session_voucher["credentialSubject"]["authorityEpoch"] == 2
@@ -349,21 +350,29 @@ def agent_call():
     intent = {"action": "transfer", "target": "vendor-1", "resource": "https://bank.example.com/x"}
     cred = signer.sign(intent=intent, valid_seconds=300)
     # A voucher minted under authority epoch 5, still well within its time window.
-    voucher = build_session_voucher(
-        subject_did=ident.did,
-        validator_dids=["did:web:v.example.com"],
-        decay_lambda=0.001,
-        initial_trust=1.0,
-        max_ttl_seconds=3600,
-        scope=["agent_actions"],
-        valid_seconds=300,
-        authority_epoch=5,
+    # The voucher is signed by its validator; an unsigned voucher never counts.
+    from vouch.vc import sign_session_voucher
+
+    v_ident = generate_identity(domain="v.example.com")
+    v_signer = Signer(private_key=v_ident.private_key_jwk, did=v_ident.did)
+    voucher = sign_session_voucher(
+        build_session_voucher(
+            subject_did=ident.did,
+            validator_dids=[v_signer.did],
+            decay_lambda=0.001,
+            initial_trust=1.0,
+            max_ttl_seconds=3600,
+            scope=["agent_actions"],
+            valid_seconds=300,
+            authority_epoch=5,
+        ),
+        v_signer,
     )
-    return signer, cred, voucher
+    return signer, cred, voucher, v_signer.get_public_key_multikey()
 
 
 def test_same_voucher_accepted_routine_rejected_when_epoch_moves(agent_call):
-    signer, cred, voucher = agent_call
+    signer, cred, voucher, vkey = agent_call
     pub = signer.get_public_key_multikey()
 
     # Routine: time-decay only. The voucher is time-valid, so the call passes.
@@ -371,6 +380,7 @@ def test_same_voucher_accepted_routine_rejected_when_epoch_moves(agent_call):
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_ROUTINE,
     )
@@ -382,6 +392,7 @@ def test_same_voucher_accepted_routine_rejected_when_epoch_moves(agent_call):
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_SENSITIVE,
         last_seen_authority_epoch=7,
@@ -394,12 +405,13 @@ def test_same_voucher_accepted_routine_rejected_when_epoch_moves(agent_call):
 
 
 def test_sensitive_passes_when_epoch_current(agent_call):
-    signer, cred, voucher = agent_call
+    signer, cred, voucher, vkey = agent_call
     pub = signer.get_public_key_multikey()
     v = verify_agent_call(
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_SENSITIVE,
         last_seen_authority_epoch=5,
@@ -409,13 +421,14 @@ def test_sensitive_passes_when_epoch_current(agent_call):
 
 
 def test_critical_requires_live_cosign(agent_call):
-    signer, cred, voucher = agent_call
+    signer, cred, voucher, vkey = agent_call
     pub = signer.get_public_key_multikey()
     # Even with a current epoch, critical demands a live co-sign.
     without = verify_agent_call(
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_CRITICAL,
         last_seen_authority_epoch=5,
@@ -427,6 +440,7 @@ def test_critical_requires_live_cosign(agent_call):
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_CRITICAL,
         last_seen_authority_epoch=5,
@@ -437,13 +451,14 @@ def test_critical_requires_live_cosign(agent_call):
 
 
 def test_voucher_epoch_read_from_credential_subject(agent_call):
-    signer, cred, voucher = agent_call
+    signer, cred, voucher, vkey = agent_call
     pub = signer.get_public_key_multikey()
     # Do not pass voucher_authority_epoch explicitly; it is read from the voucher.
     v = verify_agent_call(
         cred,
         public_key=pub,
         session_voucher=voucher,
+        voucher_public_key=vkey,
         trust_threshold=0.5,
         consequence=CONSEQUENCE_SENSITIVE,
         last_seen_authority_epoch=6,

{vouch_protocol-2.2.0 → vouch_protocol-3.0.0}/tests/test_autosign.py

@@ -217,10 +217,16 @@ class TestDelegation:
 
         kp, psigner = principal
         grant = vouch.delegate(
-            action="charge", target="api.bank", resource="invoices", signer=psigner
+            action="charge",
+            target="api.bank",
+            resource="invoices",
+            to=env_identity.did,
+            signer=psigner,
         )
 
-        @signed(parent=grant)
+        # The call's intent must sit inside the grant: same action and target,
+        # a sub-resource of the granted resource.
+        @signed(action="charge", target="api.bank", resource="invoices/42", parent=grant)
         def charge_invoice(invoice_id):
             return current_credential()
 
@@ -229,15 +235,21 @@ class TestDelegation:
         assert chain and len(chain) == 1
         assert chain[0]["issuer"] == kp.did
         assert chain[0]["subject"] == env_identity.did
-        # The agent's own credential still verifies under its own key.
-        assert _verify(cred, pubkey)[0]
+        # The agent's credential verifies under its own key, and its chain
+        # verifies against the principal's key.
+        ok, _ = Verifier.verify(cred, pubkey, trusted_roots={kp.did: kp.public_key_jwk})
+        assert ok
 
     def test_narrowing_is_enforced_no_widened_credential(self, env_identity, principal):
         kp, psigner = principal
         import vouch
 
         grant = vouch.delegate(
-            action="charge", target="api.bank", resource="invoices", signer=psigner
+            action="charge",
+            target="api.bank",
+            resource="invoices",
+            to=env_identity.did,
+            signer=psigner,
         )
 
         # Attempt to act OUTSIDE the granted resource. Signing fails the
@@ -257,7 +269,11 @@ class TestDelegation:
         import vouch
 
         grant = vouch.delegate(
-            action="charge", target="api.bank", resource="invoices", signer=psigner
+            action="charge",
+            target="api.bank",
+            resource="invoices",
+            to=env_identity.did,
+            signer=psigner,
         )
 
         @signed(action="charge", target="api.bank", resource="invoices/42", parent=grant)

{vouch_protocol-2.2.0 → vouch_protocol-3.0.0}/tests/test_caveats.py

@@ -167,3 +167,124 @@ class TestChainAndAccumulation:
     def test_empty_chain_rejected(self):
         with pytest.raises(CaveatError):
             verify_capability([], {}.get, {})
+
+
+# ---------------------------------------------------------------------------
+# Linkage, narrowing, expiry, and revocation of capability links
+# ---------------------------------------------------------------------------
+
+
+class TestLinkSecurity:
+    def _parties(self):
+        skp, store = _id("store.example.com")
+        mkp, mgr = _id("manager.example.com")
+        xkp, stranger = _id("stranger.example.com")
+        akp, agent = _id("agent.example.com")
+        keys = {
+            store.get_did(): skp.public_key_jwk,
+            mgr.get_did(): mkp.public_key_jwk,
+            stranger.get_did(): xkp.public_key_jwk,
+            agent.get_did(): akp.public_key_jwk,
+        }
+        return store, mgr, stranger, agent, keys
+
+    def _root(self, store, mgr, **kw):
+        return build_capability(
+            store,
+            to=mgr.get_did(),
+            attenuation={"action": "refund"},
+            caveats=[value_ceiling("cap", limit=200)],
+            **kw,
+        )
+
+    def test_only_the_named_delegatee_can_issue_the_next_link(self):
+        """The probe: a stranger (not the delegatee) issues a widened child."""
+        from vouch.caveats import REASON_NOT_DELEGATEE
+
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr)
+        child = build_capability(
+            stranger, to=agent.get_did(), attenuation={"action": "*"}, parent=root
+        )
+        r = verify_capability([root, child], keys.get, {"amount": 100}, root_issuer=store.get_did())
+        assert r == REASON_NOT_DELEGATEE
+
+    def test_child_attenuation_cannot_widen_parent(self):
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr)
+        child = build_capability(mgr, to=agent.get_did(), attenuation={"action": "*"}, parent=root)
+        r = verify_capability([root, child], keys.get, {"amount": 100}, root_issuer=store.get_did())
+        assert r == "scope_exceeds_parent:action"
+
+    def test_links_carry_expiry(self):
+        store, mgr, *_ = self._parties()
+        root = self._root(store, mgr, valid_seconds=600)
+        assert "validFrom" in root and "validUntil" in root
+
+    def test_expired_link_fails(self):
+        from datetime import datetime, timedelta, timezone
+
+        from vouch.caveats import REASON_EXPIRED
+
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr, valid_seconds=60)
+        later = datetime.now(timezone.utc) + timedelta(hours=2)
+        r = verify_capability(
+            [root], keys.get, {"amount": 10}, root_issuer=store.get_did(), now=later
+        )
+        assert r == REASON_EXPIRED
+
+    def test_link_without_expiry_fails(self):
+        from vouch.caveats import REASON_MALFORMED_LINK, _attach_proof
+
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr)
+        undated = {k: v for k, v in root.items() if k not in ("proof", "validUntil")}
+        undated = _attach_proof(undated, store)
+        r = verify_capability([undated], keys.get, {"amount": 10}, root_issuer=store.get_did())
+        assert r == REASON_MALFORMED_LINK
+
+    def test_child_cannot_outlive_parent(self):
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr, valid_seconds=60)
+        child = build_capability(
+            mgr,
+            to=agent.get_did(),
+            attenuation={"action": "refund"},
+            parent=root,
+            valid_seconds=86400,
+        )
+        # The builder clamps the child to its parent's window ...
+        assert child["validUntil"] <= root["validUntil"]
+        assert (
+            verify_capability([root, child], keys.get, {"amount": 10}, root_issuer=store.get_did())
+            is None
+        )
+
+    def test_revoked_link_or_issuer_fails(self):
+        from vouch.caveats import REASON_REVOKED
+
+        store, mgr, stranger, agent, keys = self._parties()
+        root = self._root(store, mgr)
+        child = build_capability(
+            mgr, to=agent.get_did(), attenuation={"action": "refund"}, parent=root
+        )
+        chain = [root, child]
+        ctx = {"amount": 10}
+        assert verify_capability(chain, keys.get, ctx, root_issuer=store.get_did()) is None
+        assert (
+            verify_capability(
+                chain, keys.get, ctx, root_issuer=store.get_did(), revoked={root["id"]}
+            )
+            == REASON_REVOKED
+        )
+        assert (
+            verify_capability(
+                chain,
+                keys.get,
+                ctx,
+                root_issuer=store.get_did(),
+                revoked=lambda i: i == mgr.get_did(),
+            )
+            == REASON_REVOKED
+        )

vouch_protocol-3.0.0/tests/test_ccg_demo.py

@@ -0,0 +1,29 @@
+"""The CCG demo scripts run offline and every case matches its expected outcome."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parent.parent
+DEMO = ROOT / "examples" / "ccg_demo"
+
+
+@pytest.mark.parametrize("script", ["01_delegation.py", "02_trust_decay.py", "03_heartbeat.py"])
+def test_demo_script_passes(script):
+    env = dict(os.environ, PYTHONPATH=str(ROOT), PYTHONDONTWRITEBYTECODE="1")
+    proc = subprocess.run(
+        [sys.executable, str(DEMO / script)],
+        cwd=str(ROOT),
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+    assert proc.returncode == 0, proc.stdout + proc.stderr
+    assert "UNEXPECTED" not in proc.stdout
+    assert "matched the expected outcome" in proc.stdout

vouch_protocol-3.0.0/tests/test_delegation_chain_vectors.py

@@ -0,0 +1,43 @@
+"""Python against the shared delegation-chain vectors (the interop contract)."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+from vouch.verifier import Verifier, verify_delegation_chain
+
+ROOT = Path(__file__).resolve().parent.parent
+VECTOR = ROOT / "test-vectors" / "delegation-chain" / "vector.json"
+CASES = json.loads(VECTOR.read_text(encoding="utf-8"))["cases"]
+
+
+def _at(iso: str) -> datetime:
+    return datetime.fromisoformat(iso.replace("Z", "+00:00"))
+
+
+def test_vector_file_matches_generator():
+    spec = importlib.util.spec_from_file_location(
+        "gen_delegation_chain_vectors", ROOT / "scripts" / "gen_delegation_chain_vectors.py"
+    )
+    gen = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(gen)
+    assert gen.render() == VECTOR.read_text(encoding="utf-8")
+
+
+@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
+def test_chain_verdict(case):
+    assert verify_delegation_chain(case["credential"], now=_at(case["now"])) == case["expected"]
+
+
+@pytest.mark.parametrize("case", CASES, ids=[c["name"] for c in CASES])
+def test_full_verify_agrees(case):
+    cred = case["credential"]
+    issuer = cred["issuer"]
+    leaf_key = issuer.split("did:key:", 1)[1]
+    ok, _ = Verifier.verify(cred, public_key=leaf_key, now=_at(case["now"]))
+    assert ok is (case["expected"] is None)