agentauthoritychain 0.5.0__tar.gz

agentauthoritychain-0.5.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: agentauthoritychain
+Version: 0.5.0
+Summary: Fail-closed AI-agent authority verification, delegated capability enforcement, and signed decision receipts
+License: Apache-2.0
+Project-URL: Homepage, https://agentauthoritychain.com/
+Project-URL: Documentation, https://agentauthoritychain.com/quickstart/
+Project-URL: Repository, https://github.com/AgentAuthorityChain/aac
+Project-URL: Security, https://agentauthoritychain.com/.well-known/security.txt
+Keywords: ai-agents,authority,delegation,authorization,capabilities,mcp,fail-closed
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=43
+Requires-Dist: truststore>=0.10.4

agentauthoritychain-0.5.0/README.md

@@ -0,0 +1,15 @@
+# AAC Python client
+
+Requires Python 3.10+. The client fails closed and verifies AAC's Ed25519 decision-receipt signature before returning an exact `permit`.
+
+```powershell
+python -m venv .venv
+.\.venv\Scripts\python.exe -m pip install .
+.\.venv\Scripts\python.exe -m aac_public_test
+```
+
+All eight credential-free AAC/AACP cases must print `PASS`. Then supply the once-shown organization credential through a secret manager or `AAC_API_CREDENTIAL`; never commit it. Use `AACClient.from_env()`, `AACClient.verify(signed_scenario)` or `AACClient.enforce(...)`. Async applications use the API-compatible `AsyncAACClient`; it preserves the same fail-closed receipt verification and supports sync or async protected operations. Private signing keys stay outside AAC.
+
+Denial is distinct from an unreliable verification: `AACDenied` means AAC returned a signed denial, while configuration, authentication, transport, protocol and receipt-signature failures use their corresponding `AAC*Error` classes. None of these errors includes the credential or authority proof.
+
+The signed-in organization console provides a domain-bound First Permit Kit for generating a local Ed25519 key and completing the first real authenticated permit.

agentauthoritychain-0.5.0/aac_client.py

@@ -0,0 +1,133 @@
+"""Fail-closed AAC verification client using the declared cryptography dependency."""
+import asyncio
+import json
+import os
+import secrets
+import time
+import urllib.error
+import urllib.request
+import base64
+try:
+    import truststore
+    truststore.inject_into_ssl()
+except ImportError:
+    pass
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+
+class AACError(Exception):
+    """Base class that never includes credentials or request bodies in its message."""
+
+
+class AACConfigurationError(AACError):
+    pass
+
+
+class AACTransportError(AACError):
+    pass
+
+
+class AACAuthenticationError(AACError):
+    pass
+
+
+class AACProtocolError(AACError):
+    pass
+
+
+class AACReceiptVerificationError(AACProtocolError):
+    pass
+
+
+class AACDenied(PermissionError, AACError):
+    pass
+
+
+class AACClient:
+    def __init__(self, credential, base_url="https://agentauthoritychain.com", timeout=8):
+        if not isinstance(credential, str) or not credential.strip():
+            raise AACConfigurationError("AAC credential is required.")
+        if not isinstance(base_url, str) or not base_url.startswith("https://"):
+            raise AACConfigurationError("AAC base URL must use HTTPS.")
+        self.credential = credential
+        self.base_url = base_url.rstrip("/")
+        self.endpoint = self.base_url + "/api/v1/verify"
+        self.key_endpoint = self.base_url + "/.well-known/aac-receipt-key.json"
+        self.timeout = timeout
+
+    @classmethod
+    def from_env(cls):
+        return cls(
+            os.environ.get("AAC_API_CREDENTIAL", ""),
+            os.environ.get("AAC_BASE_URL", "https://agentauthoritychain.com"),
+            float(os.environ.get("AAC_TIMEOUT_SECONDS", "8")),
+        )
+
+    def verify(self, signed_scenario):
+        body = json.dumps({"input_type": "signed", "signed_scenario": signed_scenario}).encode()
+        request = urllib.request.Request(self.endpoint, data=body, method="POST", headers={
+            "Authorization": f"Bearer {self.credential}", "Content-Type": "application/json",
+            "X-AAC-Timestamp": str(int(time.time())), "X-AAC-Nonce": secrets.token_urlsafe(24),
+        })
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                payload = json.load(response)
+        except urllib.error.HTTPError as exc:
+            if exc.code in (401, 403):
+                raise AACAuthenticationError("AAC rejected the client authentication.") from exc
+            raise AACTransportError("AAC verification request failed.") from exc
+        except OSError as exc:
+            raise AACTransportError("AAC verification was unavailable.") from exc
+        except (TypeError, ValueError) as exc:
+            raise AACProtocolError("AAC returned malformed JSON.") from exc
+        if not isinstance(payload, dict) or not isinstance(payload.get("result"), str):
+            raise AACProtocolError("AAC returned a malformed decision.")
+        receipt = payload.get("decision_receipt") if isinstance(payload, dict) else None
+        if not isinstance(receipt, dict):
+            raise AACProtocolError("AAC returned no decision receipt.")
+        if not self._valid_signature(receipt):
+            raise AACReceiptVerificationError("AAC receipt verification failed.")
+        if payload["result"] != "valid" or receipt.get("decision") != "permit":
+            reason = receipt.get("reason", {})
+            code = reason.get("code", "authority_denied") if isinstance(reason, dict) else "authority_denied"
+            raise AACDenied(f"AAC denied the operation: {code}.")
+        return receipt
+
+    def _valid_signature(self, receipt):
+        try:
+            signature = receipt["signature"]
+            if (receipt.get("receipt_version") != "aac-decision-receipt/1"
+                    or receipt.get("verifier") != self.base_url
+                    or signature.get("verification_key") != self.key_endpoint):
+                return False
+            with urllib.request.urlopen(self.key_endpoint, timeout=self.timeout) as response:
+                if hasattr(response, "geturl") and response.geturl() != self.key_endpoint:
+                    return False
+                key = json.load(response)
+            if key["kid"] != signature["kid"] or key["algorithm"] != "Ed25519":
+                return False
+            decode = lambda value: base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
+            unsigned = {name: value for name, value in receipt.items() if name != "signature"}
+            canonical = json.dumps(unsigned, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+            Ed25519PublicKey.from_public_bytes(decode(key["public_key"])).verify(decode(signature["value"]), canonical)
+            return True
+        except Exception:
+            return False
+
+    def enforce(self, signed_scenario, protected_operation, *args, **kwargs):
+        receipt = self.verify(signed_scenario)
+        return protected_operation(*args, **kwargs), receipt
+
+
+class AsyncAACClient(AACClient):
+    """Async facade over the dependency-minimal sync transport."""
+
+    async def verify(self, signed_scenario):
+        return await asyncio.to_thread(super().verify, signed_scenario)
+
+    async def enforce(self, signed_scenario, protected_operation, *args, **kwargs):
+        receipt = await self.verify(signed_scenario)
+        result = protected_operation(*args, **kwargs)
+        if hasattr(result, "__await__"):
+            result = await result
+        return result, receipt

agentauthoritychain-0.5.0/aac_public_test.py

@@ -0,0 +1,59 @@
+"""Credential-free AAC/AACP public conformance runner."""
+import json
+import sys
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor
+
+try:
+    import truststore
+    truststore.inject_into_ssl()
+except ImportError:
+    pass
+
+
+CASES = (
+    ("/api/v1/evaluate?case=valid", {"result": "valid", "decision": "permit"}),
+    ("/api/v1/evaluate?case=widened", {"result": "invalid", "decision": "deny"}),
+    ("/api/v1/evaluate?case=expired", {"result": "invalid", "decision": "deny"}),
+    ("/api/aacp/v1/evaluate?case=valid", {"valid": True}),
+    ("/api/aacp/v1/evaluate?case=invalid_signature", {"valid": False}),
+    ("/api/aacp/v1/evaluate?case=stale_acceptance", {"valid": False}),
+    ("/api/aacp/v1/evaluate?case=broken_event_chain", {"valid": False}),
+    ("/api/aacp/v1/evaluate?case=evidence_substitution", {"valid": False}),
+)
+
+
+def _run_case(base_url, opener, case):
+    path, expected = case
+    try:
+        request = urllib.request.Request(base_url.rstrip("/") + path, headers={"Accept": "application/json", "User-Agent": "AAC-Official-Conformance/1.0"})
+        with opener(request, timeout=30) as response:
+            payload = json.load(response)
+            if response.status != 200:
+                raise RuntimeError(f"HTTP {response.status}")
+        actual = {"valid": payload.get("valid")} if "valid" in expected else {"result": payload.get("result"), "decision": payload.get("decision_receipt", {}).get("decision")}
+        passed = actual == expected
+    except (OSError, ValueError, urllib.error.HTTPError, KeyError) as exc:
+        reason = getattr(exc, "reason", exc)
+        detail = str(reason).encode(sys.stdout.encoding or "utf-8", errors="backslashreplace").decode(sys.stdout.encoding or "utf-8", errors="replace")
+        actual, passed = {"error": type(exc).__name__, "detail": detail[:240]}, False
+    return {"path": path, "expected": expected, "actual": actual, "passed": passed}
+
+
+def run(base_url="https://agentauthoritychain.com", opener=urllib.request.urlopen):
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        return list(executor.map(lambda case: _run_case(base_url, opener, case), CASES))
+
+
+def main():
+    arguments = [item for item in sys.argv[1:] if item != "--direct"]
+    opener = urllib.request.build_opener(urllib.request.ProxyHandler({})).open if "--direct" in sys.argv[1:] else urllib.request.urlopen
+    results = run(arguments[0] if arguments else "https://agentauthoritychain.com", opener=opener)
+    for item in results:
+        print(("PASS" if item["passed"] else "FAIL"), item["path"], "" if item["passed"] else item["actual"])
+    return 0 if all(item["passed"] for item in results) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agentauthoritychain-0.5.0/aac_receipt_verifier.py

@@ -0,0 +1,27 @@
+"""Independent offline AAC decision-receipt verifier."""
+import base64
+import hashlib
+import json
+
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+
+def _decode(value): return base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
+
+
+def verify_receipt(receipt, key_document, request=None, authority_chain=None):
+    signature = receipt.get("signature", {})
+    if key_document.get("schema") == "aac-receipt-key-set/1":
+        matching = [key for key in key_document.get("keys", []) if key.get("kid") == signature.get("kid")]
+        if len(matching) != 1: return {"valid": False, "reason": "KEY_OR_ALGORITHM_MISMATCH"}
+        key_document = matching[0]
+    if signature.get("algorithm") != "Ed25519" or signature.get("kid") != key_document.get("kid"): return {"valid": False, "reason": "KEY_OR_ALGORITHM_MISMATCH"}
+    unsigned = {key: value for key, value in receipt.items() if key != "signature"}
+    canonical = json.dumps(unsigned, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+    try: Ed25519PublicKey.from_public_bytes(_decode(key_document["public_key"])).verify(_decode(signature["value"]), canonical)
+    except Exception: return {"valid": False, "reason": "INVALID_SIGNATURE"}
+    if request is not None and receipt.get("request_hash") != "sha256:" + hashlib.sha256(request).hexdigest(): return {"valid": False, "reason": "REQUEST_HASH_MISMATCH"}
+    if authority_chain is not None:
+        expected = "sha256:" + hashlib.sha256(authority_chain).hexdigest()
+        if receipt.get("authority_chain_hash") != expected: return {"valid": False, "reason": "AUTHORITY_CHAIN_HASH_MISMATCH"}
+    return {"valid": True, "decision": receipt.get("decision"), "kid": signature["kid"], "request_hash": receipt.get("request_hash"), "authority_chain_hash": receipt.get("authority_chain_hash")}

agentauthoritychain-0.5.0/agentauthoritychain.egg-info/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: agentauthoritychain
+Version: 0.5.0
+Summary: Fail-closed AI-agent authority verification, delegated capability enforcement, and signed decision receipts
+License: Apache-2.0
+Project-URL: Homepage, https://agentauthoritychain.com/
+Project-URL: Documentation, https://agentauthoritychain.com/quickstart/
+Project-URL: Repository, https://github.com/AgentAuthorityChain/aac
+Project-URL: Security, https://agentauthoritychain.com/.well-known/security.txt
+Keywords: ai-agents,authority,delegation,authorization,capabilities,mcp,fail-closed
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=43
+Requires-Dist: truststore>=0.10.4

agentauthoritychain-0.5.0/agentauthoritychain.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+aac_client.py
+aac_public_test.py
+aac_receipt_verifier.py
+pyproject.toml
+agentauthoritychain.egg-info/PKG-INFO
+agentauthoritychain.egg-info/SOURCES.txt
+agentauthoritychain.egg-info/dependency_links.txt
+agentauthoritychain.egg-info/requires.txt
+agentauthoritychain.egg-info/top_level.txt

agentauthoritychain-0.5.0/agentauthoritychain.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentauthoritychain-0.5.0/agentauthoritychain.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography>=43
+truststore>=0.10.4

agentauthoritychain-0.5.0/agentauthoritychain.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+aac_client
+aac_public_test
+aac_receipt_verifier

agentauthoritychain-0.5.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agentauthoritychain"
+version = "0.5.0"
+description = "Fail-closed AI-agent authority verification, delegated capability enforcement, and signed decision receipts"
+requires-python = ">=3.10"
+dependencies = ["cryptography>=43", "truststore>=0.10.4"]
+license = {text = "Apache-2.0"}
+keywords = ["ai-agents", "authority", "delegation", "authorization", "capabilities", "mcp", "fail-closed"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Security",
+]
+
+[project.urls]
+Homepage = "https://agentauthoritychain.com/"
+Documentation = "https://agentauthoritychain.com/quickstart/"
+Repository = "https://github.com/AgentAuthorityChain/aac"
+Security = "https://agentauthoritychain.com/.well-known/security.txt"
+
+[tool.setuptools]
+py-modules = ["aac_client", "aac_receipt_verifier", "aac_public_test"]

agentauthoritychain-0.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+